spfn 0.2.0-beta.4 → 0.2.0-beta.40

package/dist/index.js

@@ -521,35 +521,47 @@ import { existsSync as existsSync6 } from "fs";
 import { join as join6 } from "path";
 import fse3 from "fs-extra";
 async function setupApiProxy(cwd, includeAuth) {
-  const appDir = existsSync6(join6(cwd, "src", "app")) ? join6(cwd, "src", "app") : join6(cwd, "app");
+  const srcAppDir = join6(cwd, "src", "app");
+  const rootAppDir = join6(cwd, "app");
+  let appDir;
+  if (existsSync6(srcAppDir)) {
+    appDir = srcAppDir;
+  } else if (existsSync6(rootAppDir)) {
+    appDir = rootAppDir;
+  } else {
+    logger.error("Next.js app directory not found. Expected src/app or app directory.");
+    process.exit(1);
+  }
   const rpcDir = join6(appDir, "api", "rpc", "[routeName]");
   const rpcRoutePath = join6(rpcDir, "route.ts");
-  if (!existsSync6(rpcRoutePath)) {
-    ensureDirSync3(rpcDir);
-    const authImport = includeAuth ? `import '@spfn/auth/nextjs/api';
+  if (existsSync6(rpcRoutePath)) {
+    logger.error(`RPC proxy route already exists: ${rpcRoutePath.replace(cwd + "/", "")}`);
+    process.exit(1);
+  }
+  ensureDirSync3(rpcDir);
+  const authImport = includeAuth ? `import '@spfn/auth/nextjs/api';
 ` : "";
-    const routeContent = `/**
+  const routeContent = `/**
  * SPFN RPC Proxy
  *
- * Resolves routeName to actual HTTP method and path from router,
+ * Resolves routeName to actual HTTP method and path from routeMap,
  * then forwards requests to SPFN API server with automatic:
  * - Cookie forwarding
  * - Interceptor execution
  * - Header manipulation
  *
- * Note: Imports from '@spfn/core/nextjs/server' (server-only)
- * Uses next/headers internally - do not import in Client Components
+ * Note: Uses generated route-map to avoid loading server code in Next.js process.
+ * Run \`spfn codegen run\` if route-map.ts is missing.
  */
 
-${authImport}import { appRouter } from '@/server/router';
+${authImport}import { routeMap } from '@/generated/route-map';
 import { createRpcProxy } from '@spfn/core/nextjs/server';
 
-export const { GET, POST } = createRpcProxy({ router: appRouter });
+export const { GET, POST } = createRpcProxy({ routeMap });
 `;
-    writeFileSync2(rpcRoutePath, routeContent);
-    const relativePath = rpcRoutePath.replace(cwd + "/", "");
-    logger.success(`Created ${relativePath} (RPC proxy)`);
-  }
+  writeFileSync2(rpcRoutePath, routeContent);
+  const relativePath = rpcRoutePath.replace(cwd + "/", "");
+  logger.success(`Created ${relativePath} (RPC proxy)`);
 }
 var ensureDirSync3, writeFileSync2;
 var init_api_proxy = __esm({
@@ -741,6 +753,23 @@ var init_deployment_config = __esm({
   }
 });
 
+// src/utils/version.ts
+function getCliVersion() {
+  return "0.2.0-beta.40";
+}
+function getTagFromVersion(version) {
+  const match = version.match(/-([a-z]+)\./i);
+  return match ? match[1] : "latest";
+}
+function getSpfnTag() {
+  return getTagFromVersion(getCliVersion());
+}
+var init_version = __esm({
+  "src/utils/version.ts"() {
+    "use strict";
+  }
+});
+
 // src/commands/init/steps/package.ts
 import ora3 from "ora";
 import { execa as execa2 } from "execa";
@@ -750,13 +779,15 @@ async function setupPackageJson(cwd, packageJsonPath, packageJson, packageManage
   packageJson.dependencies = packageJson.dependencies || {};
   packageJson.devDependencies = packageJson.devDependencies || {};
   packageJson.scripts = packageJson.scripts || {};
-  packageJson.dependencies["@spfn/core"] = "alpha";
+  const spfnTag = getSpfnTag();
+  packageJson.dependencies["@spfn/core"] = spfnTag;
   packageJson.dependencies["@sinclair/typebox"] = "^0.34.0";
+  packageJson.dependencies["drizzle-orm"] = "^0.45.0";
   packageJson.dependencies["drizzle-typebox"] = "^0.1.0";
-  packageJson.dependencies["spfn"] = "alpha";
+  packageJson.dependencies["spfn"] = spfnTag;
   packageJson.dependencies["concurrently"] = "^9.2.1";
   if (includeAuth) {
-    packageJson.dependencies["@spfn/auth"] = "alpha";
+    packageJson.dependencies["@spfn/auth"] = spfnTag;
   }
   packageJson.devDependencies["@types/node"] = "^20.11.0";
   packageJson.devDependencies["tsx"] = "^4.20.6";
@@ -793,6 +824,7 @@ var init_package = __esm({
   "src/commands/init/steps/package.ts"() {
     "use strict";
     init_logger();
+    init_version();
     ({ writeFileSync: writeFileSync4 } = fse6);
   }
 });
@@ -802,26 +834,7 @@ import { existsSync as existsSync9, readFileSync as readFileSync2 } from "fs";
 import { join as join9 } from "path";
 import fse7 from "fs-extra";
 async function setupConfigFiles(cwd) {
-  const envExamplePath = join9(cwd, ".env.local.example");
-  if (!existsSync9(envExamplePath)) {
-    const envExampleContent = `# Environment
-NODE_ENV=local
-
-# Logging
-SPFN_LOG_LEVEL=info
-
-# Database (matches docker-compose.yml)
-DATABASE_URL=postgresql://spfn:spfn@localhost:5432/spfn_dev
-
-# Cache - Redis/Valkey (optional)
-CACHE_URL=redis://localhost:6379
-
-# SPFN API Server URL (for API Route Proxy and SSR)
-SPFN_API_URL=http://localhost:8790
-`;
-    writeFileSync5(envExamplePath, envExampleContent);
-    logger.success("Created .env.local.example");
-  }
+  generateEnvExamples(cwd);
   const spfnrcPath = join9(cwd, ".spfnrc.ts");
   if (!existsSync9(spfnrcPath)) {
     const spfnrcContent = `import { defineConfig, defineGenerator } from '@spfn/core/codegen';
@@ -830,64 +843,135 @@ SPFN_API_URL=http://localhost:8790
  * SPFN Codegen Configuration
  *
  * Configure code generators here. Generators run during \`spfn dev\` and \`spfn codegen run\`.
- *
- * Example: Custom generator
- * @example
- * const myGenerator = defineGenerator({
- *     name: 'my-package:generator',
- *     enabled: true,
- *     // ... generator-specific options
- * });
- *
- * Example: File-based generator
- * @example
- * const customGen = defineGenerator({
- *     path: './src/generators/my-generator.ts',
- * });
  */
 
 export default defineConfig({
     generators: [
-        // Add your generators here
-        // myGenerator,
+        // Route map generator - generates routeName \u2192 {method, path} mappings
+        // Used by RPC proxy to resolve routes without importing server code
+        defineGenerator({
+            name: '@spfn/core:route-map',
+            routerPath: './src/server/router.ts',
+            outputPath: './src/generated/route-map.ts',
+        }),
     ]
 });
 `;
     writeFileSync5(spfnrcPath, spfnrcContent);
     logger.success("Created .spfnrc.ts (codegen configuration)");
   }
+  updateGitignore(cwd);
+  updateTsconfig(cwd);
+}
+function generateEnvExamples(cwd) {
+  writeEnvExample(cwd, ".env.example", `# Shared defaults (committed)
+# These values are shared across all environments.
+
+# Environment
+NODE_ENV=local
+
+# Logging
+SPFN_LOG_LEVEL=info
+
+# Server
+PORT=4000
+
+# SPFN API Server URL (for API Route Proxy and SSR)
+SPFN_API_URL=http://localhost:8790
+NEXT_PUBLIC_SPFN_API_URL=http://localhost:8790
+`);
+  writeEnvExample(cwd, ".env.local.example", `# Local overrides (gitignored)
+# Developer-specific values that should NOT be committed.
+
+# Database (matches docker-compose.yml)
+DATABASE_URL=postgresql://spfn:spfn@localhost:5432/spfn_dev
+
+# Cache - Redis/Valkey (optional)
+CACHE_URL=redis://localhost:6379
+
+# SPFN App URL (optional, for CORS and redirects)
+# SPFN_APP_URL=http://localhost:3790
+`);
+  writeEnvExample(cwd, ".env.server.example", `# Server-only defaults (committed)
+# These values are only loaded by the SPFN server, not by Next.js.
+
+# Database pool
+DB_POOL_MAX=10
+DB_POOL_IDLE_TIMEOUT=30
+
+# Server timeouts
+SERVER_TIMEOUT=120000
+SHUTDOWN_TIMEOUT=30000
+`);
+  writeEnvExample(cwd, ".env.server.local.example", `# Server secrets (gitignored)
+# Server-only sensitive values. Never commit this file.
+
+# Database write/read URLs (master-replica pattern, optional)
+# DATABASE_WRITE_URL=postgresql://user:password@master:5432/dbname
+# DATABASE_READ_URL=postgresql://user:password@replica:5432/dbname
+
+# Cache password (optional)
+# CACHE_PASSWORD=your-redis-password
+`);
+}
+function writeEnvExample(cwd, filename, content) {
+  const filePath = join9(cwd, filename);
+  if (existsSync9(filePath)) {
+    return;
+  }
+  writeFileSync5(filePath, content);
+  logger.success(`Created ${filename}`);
+}
+function updateGitignore(cwd) {
   const gitignorePath = join9(cwd, ".gitignore");
-  if (existsSync9(gitignorePath)) {
-    try {
-      const gitignoreContent = readFileSync2(gitignorePath, "utf-8");
-      if (!gitignoreContent.includes(".spfn")) {
-        const updatedContent = gitignoreContent.replace(
-          /# production\n\/build/,
-          "# production\n/build\n\n# spfn\n/.spfn/"
-        );
-        writeFileSync5(gitignorePath, updatedContent);
-        logger.success("Updated .gitignore with .spfn directory");
-      }
-    } catch (error) {
-      logger.warn("Could not update .gitignore (you can add .spfn manually)");
+  if (!existsSync9(gitignorePath)) {
+    return;
+  }
+  try {
+    const content = readFileSync2(gitignorePath, "utf-8");
+    let updated = content;
+    let changed = false;
+    if (!content.includes(".spfn")) {
+      updated = updated.replace(
+        /# production\n\/build/,
+        "# production\n/build\n\n# spfn\n/.spfn/"
+      );
+      changed = true;
+    }
+    if (!content.includes(".env.local") && !content.includes(".env.*.local")) {
+      updated += `
+# environment secrets (local overrides)
+.env.local
+.env.*.local
+`;
+      changed = true;
+    }
+    if (changed) {
+      writeFileSync5(gitignorePath, updated);
+      logger.success("Updated .gitignore with .spfn directory and env patterns");
     }
+  } catch (error) {
+    logger.warn("Could not update .gitignore (you can add patterns manually)");
   }
+}
+function updateTsconfig(cwd) {
   const tsconfigPath = join9(cwd, "tsconfig.json");
-  if (existsSync9(tsconfigPath)) {
-    try {
-      const tsconfigContent = readFileSync2(tsconfigPath, "utf-8");
-      const tsconfig = JSON.parse(tsconfigContent);
-      if (!tsconfig.exclude) {
-        tsconfig.exclude = [];
-      }
-      if (!tsconfig.exclude.includes("src/server")) {
-        tsconfig.exclude.push("src/server");
-        writeFileSync5(tsconfigPath, JSON.stringify(tsconfig, null, 2) + "\n");
-        logger.success("Updated tsconfig.json (excluded src/server for Vercel compatibility)");
-      }
-    } catch (error) {
-      logger.warn('Could not update tsconfig.json (you can add "src/server" to exclude manually)');
+  if (!existsSync9(tsconfigPath)) {
+    return;
+  }
+  try {
+    const tsconfigContent = readFileSync2(tsconfigPath, "utf-8");
+    const tsconfig = JSON.parse(tsconfigContent);
+    if (!tsconfig.exclude) {
+      tsconfig.exclude = [];
+    }
+    if (!tsconfig.exclude.includes("src/server")) {
+      tsconfig.exclude.push("src/server");
+      writeFileSync5(tsconfigPath, JSON.stringify(tsconfig, null, 2) + "\n");
+      logger.success("Updated tsconfig.json (excluded src/server for Vercel compatibility)");
     }
+  } catch (error) {
+    logger.warn('Could not update tsconfig.json (you can add "src/server" to exclude manually)');
   }
 }
 var writeFileSync5;
@@ -958,10 +1042,10 @@ __export(function_migrations_exports, {
   discoverFunctionMigrations: () => discoverFunctionMigrations,
   executeFunctionMigrations: () => executeFunctionMigrations
 });
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 import { join as join15 } from "path";
 import { env as env2 } from "@spfn/core/config";
-import { loadEnvFiles as loadEnvFiles2 } from "@spfn/core/server";
+import { loadEnv as loadEnv2 } from "@spfn/core/server";
 import { existsSync as existsSync16, readdirSync as readdirSync2, readFileSync as readFileSync5 } from "fs";
 function discoverFunctionMigrations(cwd = process.cwd()) {
   const nodeModulesPath = join15(cwd, "node_modules");
@@ -989,7 +1073,7 @@ function discoverFunctionMigrations(cwd = process.cwd()) {
       const migrationsDir = join15(packagePath, spfnConfig.migrations.dir);
       if (!existsSync16(migrationsDir)) {
         console.warn(
-          chalk11.yellow(`\u26A0\uFE0F  Package @spfn/${pkg} specifies migrations but directory not found: ${migrationsDir}`)
+          chalk12.yellow(`\u26A0\uFE0F  Package @spfn/${pkg} specifies migrations but directory not found: ${migrationsDir}`)
         );
         continue;
       }
@@ -999,28 +1083,99 @@ function discoverFunctionMigrations(cwd = process.cwd()) {
         packagePath
       });
     } catch (error) {
-      console.warn(chalk11.yellow(`\u26A0\uFE0F  Failed to parse package.json for @spfn/${pkg}`));
+      console.warn(chalk12.yellow(`\u26A0\uFE0F  Failed to parse package.json for @spfn/${pkg}`));
     }
   }
   return functions;
 }
+async function migrateLegacyTable(db, functionMigrations) {
+  const legacyCheck = await db.execute(
+    `SELECT EXISTS (
+            SELECT 1 FROM information_schema.tables
+            WHERE table_schema = 'drizzle' AND table_name = '__spfn_fn_migrations'
+        ) AS "exists"`
+  );
+  if (!legacyCheck[0]?.exists) {
+    return;
+  }
+  console.log(chalk12.dim("\n  Migrating legacy shared migration table to per-package tables..."));
+  const legacyRows = await db.execute(
+    `SELECT hash, created_at FROM drizzle."__spfn_fn_migrations" ORDER BY id`
+  );
+  if (legacyRows.length === 0) {
+    await db.execute(`DROP TABLE drizzle."__spfn_fn_migrations"`);
+    return;
+  }
+  for (const func of functionMigrations) {
+    const journalPath = join15(func.migrationsDir, "meta", "_journal.json");
+    if (!existsSync16(journalPath)) {
+      continue;
+    }
+    const journal = JSON.parse(readFileSync5(journalPath, "utf-8"));
+    const entries = journal.entries || [];
+    const tableName = `__spfn_fn_${func.packageName.replace("@spfn/", "")}_migrations`;
+    await db.execute(
+      `CREATE SCHEMA IF NOT EXISTS drizzle`
+    );
+    await db.execute(
+      `CREATE TABLE IF NOT EXISTS drizzle."${tableName}" (
+                id serial PRIMARY KEY,
+                hash text NOT NULL,
+                created_at bigint
+            )`
+    );
+    const existing = await db.execute(
+      `SELECT COUNT(*) AS "count" FROM drizzle."${tableName}"`
+    );
+    if (Number(existing[0]?.count) > 0) {
+      continue;
+    }
+    const { createHash } = await import("crypto");
+    let copied = 0;
+    for (const entry of entries) {
+      const sqlPath = join15(func.migrationsDir, `${entry.tag}.sql`);
+      if (!existsSync16(sqlPath)) {
+        continue;
+      }
+      const sqlContent = readFileSync5(sqlPath, "utf-8");
+      const hash = createHash("sha256").update(sqlContent).digest("hex");
+      const found = legacyRows.find((r) => r.hash === hash);
+      if (found) {
+        await db.execute(
+          `INSERT INTO drizzle."${tableName}" (hash, created_at) VALUES ('${hash}', ${entry.when})`
+        );
+        copied++;
+      }
+    }
+    if (copied > 0) {
+      console.log(chalk12.dim(`    \u2713 ${func.packageName}: copied ${copied} migration record(s)`));
+    }
+  }
+  await db.execute(`DROP TABLE drizzle."__spfn_fn_migrations"`);
+  console.log(chalk12.dim("    \u2713 Legacy migration table removed\n"));
+}
 async function executeFunctionMigrations(functionMigrations) {
   let executedCount = 0;
   const { drizzle } = await import("drizzle-orm/postgres-js");
   const { migrate } = await import("drizzle-orm/postgres-js/migrator");
   const postgres = await import("postgres");
-  loadEnvFiles2();
+  loadEnv2();
   if (!env2.DATABASE_URL) {
     throw new Error("DATABASE_URL not found in environment");
   }
   const connection = postgres.default(env2.DATABASE_URL, { max: 1 });
   const db = drizzle(connection);
   try {
+    await migrateLegacyTable(db, functionMigrations);
     for (const func of functionMigrations) {
-      console.log(chalk11.blue(`
+      console.log(chalk12.blue(`
   \u{1F4E6} Running ${func.packageName} migrations...`));
-      await migrate(db, { migrationsFolder: func.migrationsDir });
-      console.log(chalk11.green(`  \u2713 ${func.packageName} migrations applied`));
+      const tableName = `__spfn_fn_${func.packageName.replace("@spfn/", "")}_migrations`;
+      await migrate(db, {
+        migrationsFolder: func.migrationsDir,
+        migrationsTable: tableName
+      });
+      console.log(chalk12.green(`  \u2713 ${func.packageName} migrations applied`));
       executedCount++;
     }
   } finally {
@@ -1179,10 +1334,30 @@ init_init();
 init_logger();
 init_package_manager();
 import { Command as Command4 } from "commander";
-import { existsSync as existsSync11, readFileSync as readFileSync3, writeFileSync as writeFileSync6, mkdirSync } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync3, writeFileSync as writeFileSync6, mkdirSync, unlinkSync, rmSync, watch } from "fs";
 import { join as join11 } from "path";
 import { execa as execa4 } from "execa";
 import chokidar from "chokidar";
+function waitForReadyFile(filePath, timeoutMs = 3e4) {
+  return new Promise((resolve2, reject) => {
+    if (existsSync11(filePath)) {
+      unlinkSync(filePath);
+    }
+    const timer = setTimeout(() => {
+      watcher.close();
+      reject(new Error(`Server did not become ready within ${timeoutMs / 1e3}s`));
+    }, timeoutMs);
+    const dir = join11(filePath, "..");
+    const fileName = filePath.split("/").pop();
+    const watcher = watch(dir, (event, name) => {
+      if (name === fileName && existsSync11(filePath)) {
+        watcher.close();
+        clearTimeout(timer);
+        resolve2(readFileSync3(filePath, "utf-8").trim());
+      }
+    });
+  });
+}
 var devCommand = new Command4("dev").description("Start SPFN development server (detects and runs Next.js + Hono)").option("-p, --port <port>", "Server port").option("-H, --host <host>", "Server host").option("--routes <path>", "Routes directory path").option("--server-only", "Run only Hono server (skip Next.js)").option("--watch", "Enable hot reload (watch mode)").action(async (options) => {
   process.setMaxListeners(20);
   if (!process.env.NODE_ENV) {
@@ -1205,22 +1380,36 @@ var devCommand = new Command4("dev").description("Start SPFN development server
   const serverEntry = join11(tempDir, "server.mjs");
   const watcherEntry = join11(tempDir, "watcher.mjs");
   mkdirSync(tempDir, { recursive: true });
+  const serverBuildDir = join11(tempDir, "server");
+  if (existsSync11(serverBuildDir)) {
+    rmSync(serverBuildDir, { recursive: true, force: true });
+    logger.info("[SPFN] Cleaned stale build cache (.spfn/server)");
+  }
+  const readySignal = join11(tempDir, "server-ready");
+  if (existsSync11(readySignal)) {
+    unlinkSync(readySignal);
+  }
   const configParts = [];
   if (options.port) configParts.push(`port: ${options.port}`);
   if (options.host) configParts.push(`host: '${options.host}'`);
   if (options.routes) configParts.push(`routesPath: '${options.routes}'`);
   configParts.push("debug: true");
+  const readyFile = join11(tempDir, "server-ready");
   writeFileSync6(serverEntry, `
+import { writeFileSync } from 'fs';
+
 // Load environment variables FIRST (before any imports that depend on them)
-// Use centralized environment loader for standard dotenv priority
 await import('@spfn/core/config');
 
 // Import and start server
 const { startServer } = await import('@spfn/core/server');
 
-await startServer({
+const instance = await startServer({
     ${configParts.join(",\n    ")}
 });
+
+// Signal ready with actual port
+writeFileSync(${JSON.stringify(readyFile)}, String(instance.config.port));
 `);
   writeFileSync6(watcherEntry, `
 // Load environment variables
@@ -1277,7 +1466,9 @@ catch (error)
   const pm = detectPackageManager(cwd);
   if (options.serverOnly || !hasNext) {
     const watchMode2 = options.watch === true;
-    logger.info(`Starting SPFN Server on http://${options.host}:${options.port}${watchMode2 ? " (watch mode)" : ""}
+    const host = options.host ?? process.env.HOST ?? "localhost";
+    const port = options.port ?? process.env.PORT ?? "4000";
+    logger.info(`Starting SPFN Server on http://${host}:${port}${watchMode2 ? " (watch mode)" : ""}
 `);
     let serverProcess2 = null;
     let watcherProcess2 = null;
@@ -1471,7 +1662,13 @@ catch (error)
   process.on("SIGTERM", cleanup);
   startWatcher();
   startServer();
-  await new Promise((resolve2) => setTimeout(resolve2, 2e3));
+  try {
+    const port = await waitForReadyFile(readyFile);
+    logger.info(`[SPFN] Server ready on port ${port}, starting Next.js...
+`);
+  } catch (error) {
+    logger.warn(`[SPFN] Server readiness check timed out, starting Next.js anyway...`);
+  }
   startNext();
   await new Promise((resolve2) => {
     const keepAlive = setInterval(() => {
@@ -1522,7 +1719,7 @@ async function buildProject(options) {
       const orchestrator = new CodegenOrchestrator({
         generators,
         cwd,
-        debug: false
+        debug: true
       });
       await orchestrator.generateAll();
       spinner.succeed("API client generated");
@@ -1832,7 +2029,7 @@ async function runGenerators() {
   const orchestrator = new CodegenOrchestrator({
     generators,
     cwd,
-    debug: false
+    debug: true
   });
   await orchestrator.generateAll();
   console.log("\n" + chalk7.green.bold("\u2713 Code generation completed"));
@@ -1991,14 +2188,15 @@ import { Command as Command9 } from "commander";
 import chalk10 from "chalk";
 
 // src/commands/db/utils/drizzle.ts
-import { existsSync as existsSync15, writeFileSync as writeFileSync9, unlinkSync } from "fs";
+import { existsSync as existsSync15, writeFileSync as writeFileSync9, unlinkSync as unlinkSync2 } from "fs";
 import { spawn } from "child_process";
+import { pathToFileURL } from "url";
 import chalk9 from "chalk";
 import ora6 from "ora";
 import { env } from "@spfn/core/config";
-import { loadEnvFiles } from "@spfn/core/server";
+import { loadEnv } from "@spfn/core/server";
 function validateDatabasePrerequisites() {
-  loadEnvFiles();
+  loadEnv();
   if (!env.DATABASE_URL) {
     console.error(chalk9.red("\u274C DATABASE_URL not found in environment"));
     console.log(chalk9.yellow("\n\u{1F4A1} Tip: Add DATABASE_URL to your .env file"));
@@ -2010,7 +2208,7 @@ async function runDrizzleCommand(command) {
   const tempConfigPath = `./drizzle.config.${process.pid}.${Date.now()}.temp.ts`;
   const configPath = hasUserConfig ? "./drizzle.config.ts" : tempConfigPath;
   if (!hasUserConfig) {
-    loadEnvFiles();
+    loadEnv();
     if (!env.DATABASE_URL) {
       console.error(chalk9.red("\u274C DATABASE_URL not found in environment"));
       console.log(chalk9.yellow("\n\u{1F4A1} Tip: Add DATABASE_URL to your .env file"));
@@ -2020,7 +2218,10 @@ async function runDrizzleCommand(command) {
     const configContent = generateDrizzleConfigFile({
       cwd: process.cwd(),
       // Exclude package schemas to avoid .ts/.js mixing (packages use migrations instead)
-      disablePackageDiscovery: true
+      disablePackageDiscovery: true,
+      // Expand globs and auto-detect PostgreSQL schemas for push/generate compatibility
+      expandGlobs: true,
+      autoDetectSchemas: true
     });
     writeFileSync9(tempConfigPath, configContent);
     console.log(chalk9.dim("Using auto-generated Drizzle config\n"));
@@ -2031,11 +2232,12 @@ async function runDrizzleCommand(command) {
     const drizzleProcess = spawn("drizzle-kit", args, {
       stdio: "inherit",
       // Allow interactive input
-      shell: true
+      shell: true,
+      env: { ...process.env, NODE_TLS_REJECT_UNAUTHORIZED: "0" }
     });
     const cleanup = () => {
       if (!hasUserConfig && existsSync15(tempConfigPath)) {
-        unlinkSync(tempConfigPath);
+        unlinkSync2(tempConfigPath);
       }
     };
     drizzleProcess.on("close", (code) => {
@@ -2064,6 +2266,43 @@ async function runWithSpinner(spinnerText, command, successMessage, failMessage)
     process.exit(1);
   }
 }
+async function ensureTsxLoader() {
+}
+async function loadSchemaImports(schemaFiles) {
+  const hasTsFiles = schemaFiles.some((f) => f.endsWith(".ts"));
+  if (hasTsFiles) {
+    await ensureTsxLoader();
+  }
+  const imports = {};
+  for (const file of schemaFiles) {
+    const moduleUrl = pathToFileURL(file).href;
+    const mod = await import(moduleUrl);
+    for (const [key, value] of Object.entries(mod)) {
+      if (key !== "default") {
+        imports[key] = value;
+      }
+    }
+  }
+  return imports;
+}
+async function createPushConnection() {
+  loadEnv();
+  if (!env.DATABASE_URL) {
+    throw new Error("DATABASE_URL is required");
+  }
+  process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+  const pg = await import("pg");
+  const { drizzle } = await import("drizzle-orm/node-postgres");
+  const pool = new pg.default.Pool({
+    connectionString: env.DATABASE_URL,
+    max: 1
+  });
+  const db = drizzle(pool);
+  return {
+    db,
+    close: () => pool.end()
+  };
+}
 
 // src/commands/db/generate.ts
 async function dbGenerate() {
@@ -2078,41 +2317,238 @@ async function dbGenerate() {
 }
 
 // src/commands/db/push.ts
-import chalk12 from "chalk";
+import chalk13 from "chalk";
+import prompts3 from "prompts";
 import "@spfn/core/config";
-async function dbPush() {
-  await runWithSpinner(
-    "Pushing schema changes to database...",
-    "push",
-    "Schema pushed successfully",
-    "Failed to push schema"
-  );
-  const { discoverFunctionMigrations: discoverFunctionMigrations2, executeFunctionMigrations: executeFunctionMigrations2 } = await Promise.resolve().then(() => (init_function_migrations(), function_migrations_exports));
-  const functions = discoverFunctionMigrations2(process.cwd());
-  if (functions.length > 0) {
-    console.log(chalk12.blue("\n\u{1F4E6} Applying function package migrations:"));
-    functions.forEach((func) => {
-      console.log(chalk12.dim(`  - ${func.packageName}`));
-    });
+import { loadEnv as loadEnv3 } from "@spfn/core/server";
+import { sql } from "drizzle-orm";
+import { getTableConfig } from "drizzle-orm/pg-core";
+
+// src/commands/db/utils/sql-classifier.ts
+var DESTRUCTIVE_PATTERNS = [
+  { pattern: /^\s*DROP\s+TABLE/i, reason: "Drops entire table" },
+  { pattern: /^\s*DROP\s+INDEX/i, reason: "Drops index" },
+  { pattern: /^\s*DROP\s+SCHEMA/i, reason: "Drops schema" },
+  { pattern: /^\s*DROP\s+TYPE/i, reason: "Drops custom type" },
+  { pattern: /ALTER\s+TABLE\s+.*\bDROP\s+COLUMN\b/i, reason: "Drops column" },
+  { pattern: /ALTER\s+TABLE\s+.*\bDROP\s+CONSTRAINT\b/i, reason: "Drops constraint" },
+  { pattern: /ALTER\s+TABLE\s+.*ALTER\s+COLUMN\s+.*\bTYPE\b/i, reason: "Changes column type (potential data loss)" },
+  { pattern: /ALTER\s+TYPE\s+.*\bRENAME\s+VALUE\b/i, reason: "Renames enum value" },
+  { pattern: /^\s*TRUNCATE\b/i, reason: "Truncates table data" },
+  { pattern: /^\s*DELETE\s+FROM\b/i, reason: "Deletes table data" }
+];
+var WARNING_PATTERNS = [
+  { pattern: /ALTER\s+TABLE\s+.*ALTER\s+COLUMN\s+.*\bSET\s+NOT\s+NULL\b/i, reason: "Adds NOT NULL (fails if NULLs exist)" },
+  { pattern: /ALTER\s+TABLE\s+.*\bRENAME\s+COLUMN\b/i, reason: "Renames column" }
+];
+function classifyStatement(sql2) {
+  for (const { pattern, reason } of DESTRUCTIVE_PATTERNS) {
+    if (pattern.test(sql2)) {
+      return { sql: sql2, category: "destructive", reason };
+    }
+  }
+  for (const { pattern, reason } of WARNING_PATTERNS) {
+    if (pattern.test(sql2)) {
+      return { sql: sql2, category: "warning", reason };
+    }
+  }
+  return { sql: sql2, category: "safe", reason: "" };
+}
+function classifyStatements(statements) {
+  const result = { safe: [], destructive: [], warning: [] };
+  for (const sql2 of statements) {
+    const classified = classifyStatement(sql2);
+    result[classified.category].push(classified);
+  }
+  return result;
+}
+
+// src/commands/db/utils/push-display.ts
+import chalk11 from "chalk";
+function formatSql(sql2) {
+  return sql2.replace(/\s+/g, " ").trim();
+}
+function printStatements(statements, color) {
+  for (const stmt of statements) {
+    console.log(color(`   ${formatSql(stmt.sql)}`));
+    if (stmt.reason) {
+      console.log(chalk11.dim(`   \u2192 ${stmt.reason}`));
+    }
+  }
+}
+function displayClassifiedStatements(result) {
+  if (result.safe.length > 0) {
+    console.log(chalk11.green(`
+\u2705 Safe changes (${result.safe.length}):`));
+    printStatements(result.safe, chalk11.green);
+  }
+  if (result.warning.length > 0) {
+    console.log(chalk11.yellow(`
+\u26A0\uFE0F  Warnings (${result.warning.length}):`));
+    printStatements(result.warning, chalk11.yellow);
+  }
+  if (result.destructive.length > 0) {
+    console.log(chalk11.red(`
+\u274C Destructive changes (${result.destructive.length}):`));
+    printStatements(result.destructive, chalk11.red);
+  }
+}
+function displayDryRunSummary(result) {
+  const total = result.safe.length + result.warning.length + result.destructive.length;
+  console.log(chalk11.cyan(`
+\u{1F50D} Dry-run: ${total} statement(s) detected
+`));
+  displayClassifiedStatements(result);
+  console.log("");
+}
+function displayApplySummary(applied, skipped) {
+  if (applied > 0) {
+    console.log(chalk11.green(`
+\u2705 Applied ${applied} statement(s)`));
+  }
+  if (skipped > 0) {
+    console.log(chalk11.yellow(`\u23ED\uFE0F  Skipped ${skipped} destructive statement(s)`));
+  }
+  console.log("");
+}
+
+// src/commands/db/push.ts
+async function dbPush(options = {}) {
+  validateDatabasePrerequisites();
+  loadEnv3();
+  const { getDrizzleConfig } = await import("@spfn/core/db");
+  const config = getDrizzleConfig({
+    cwd: process.cwd(),
+    expandGlobs: true,
+    autoDetectSchemas: true,
+    disablePackageDiscovery: true
+  });
+  const schemaFiles = Array.isArray(config.schema) ? config.schema : [config.schema];
+  if (schemaFiles.length === 0) {
+    console.log(chalk13.yellow("No schema files found."));
+    return;
+  }
+  console.log(chalk13.dim(`Found ${schemaFiles.length} schema file(s)
+`));
+  const imports = await loadSchemaImports(schemaFiles);
+  const detectedSchemas = new Set(config.schemaFilter ?? ["public"]);
+  for (const value of Object.values(imports)) {
     try {
-      await executeFunctionMigrations2(functions);
-      console.log(chalk12.green("\n\u2705 All function migrations applied\n"));
-    } catch (error) {
-      console.error(chalk12.red("\n\u274C Failed to apply function migrations"));
-      console.error(chalk12.red(error instanceof Error ? error.message : "Unknown error"));
-      process.exit(1);
+      const cfg = getTableConfig(value);
+      if (cfg.schema) {
+        detectedSchemas.add(cfg.schema);
+      }
+    } catch {
     }
   }
+  const schemaFilter = Array.from(detectedSchemas);
+  const { db, close } = await createPushConnection();
+  try {
+    const { pushSchema } = await import("drizzle-kit/api");
+    const { statementsToExecute } = await pushSchema(
+      imports,
+      db,
+      schemaFilter
+    );
+    const managedSchemaSet = new Set(schemaFilter);
+    const statements = statementsToExecute.filter((s) => {
+      const dropMatch = s.match(/^\s*DROP\s+SCHEMA\s+"?([^"\s;]+)"?/i);
+      if (dropMatch && managedSchemaSet.has(dropMatch[1])) {
+        console.log(chalk13.dim(`  [skip] DROP SCHEMA "${dropMatch[1]}" \u2014 managed schema, ignoring`));
+        return false;
+      }
+      return true;
+    }).map(
+      (s) => s.replace(/^CREATE SCHEMA(?!\s+IF\s+NOT\s+EXISTS)/i, "CREATE SCHEMA IF NOT EXISTS")
+    );
+    if (statements.length === 0) {
+      console.log(chalk13.green("\u2705 No changes detected \u2014 database is up to date\n"));
+      await applyFunctionMigrations();
+      return;
+    }
+    const result = classifyStatements(statements);
+    if (options.dryRun) {
+      displayDryRunSummary(result);
+      return;
+    }
+    displayClassifiedStatements(result);
+    if (options.force) {
+      console.log(chalk13.dim("\n--force: applying all changes..."));
+      for (const stmt of statements) {
+        await db.execute(sql.raw(stmt));
+      }
+      displayApplySummary(statements.length, 0);
+    } else if (result.destructive.length === 0) {
+      for (const stmt of statements) {
+        await db.execute(sql.raw(stmt));
+      }
+      displayApplySummary(statements.length, 0);
+    } else {
+      const safeCount = result.safe.length + result.warning.length;
+      if (safeCount > 0) {
+        for (const stmt of [...result.safe, ...result.warning]) {
+          await db.execute(sql.raw(stmt.sql));
+        }
+        console.log(chalk13.green(`
+\u2705 Applied ${safeCount} safe statement(s)`));
+      }
+      console.log(chalk13.red(`
+\u274C ${result.destructive.length} destructive change(s) require confirmation:`));
+      for (const stmt of result.destructive) {
+        console.log(chalk13.red(`   ${stmt.sql.replace(/\s+/g, " ").trim()}`));
+        console.log(chalk13.dim(`   \u2192 ${stmt.reason}`));
+      }
+      const { confirm } = await prompts3({
+        type: "confirm",
+        name: "confirm",
+        message: "Apply destructive changes?",
+        initial: false
+      });
+      if (confirm) {
+        for (const stmt of result.destructive) {
+          await db.execute(sql.raw(stmt.sql));
+        }
+        displayApplySummary(statements.length, 0);
+      } else {
+        displayApplySummary(safeCount, result.destructive.length);
+        console.log(chalk13.dim("Tip: Use --force to apply all changes without prompting.\n"));
+      }
+    }
+    await applyFunctionMigrations();
+  } finally {
+    await close();
+  }
+}
+async function applyFunctionMigrations() {
+  const { discoverFunctionMigrations: discoverFunctionMigrations2, executeFunctionMigrations: executeFunctionMigrations2 } = await Promise.resolve().then(() => (init_function_migrations(), function_migrations_exports));
+  const functions = discoverFunctionMigrations2(process.cwd());
+  if (functions.length === 0) {
+    return;
+  }
+  console.log(chalk13.blue("\n\u{1F4E6} Applying function package migrations:"));
+  functions.forEach((func) => {
+    console.log(chalk13.dim(`  - ${func.packageName}`));
+  });
+  try {
+    await executeFunctionMigrations2(functions);
+    console.log(chalk13.green("\n\u2705 All function migrations applied\n"));
+  } catch (error) {
+    console.error(chalk13.red("\n\u274C Failed to apply function migrations"));
+    console.error(chalk13.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
 }
 
 // src/commands/db/migrate.ts
-import chalk16 from "chalk";
+import chalk17 from "chalk";
+import { join as join16 } from "path";
+import { existsSync as existsSync18 } from "fs";
 
 // src/commands/db/backup.ts
 import { promises as fs3 } from "fs";
 import path3 from "path";
 import { spawn as spawn2 } from "child_process";
-import chalk15 from "chalk";
+import chalk16 from "chalk";
 import ora7 from "ora";
 
 // src/commands/db/utils/database.ts
@@ -2181,14 +2617,14 @@ function formatTimestamp() {
 import { promises as fs2 } from "fs";
 import { existsSync as existsSync17 } from "fs";
 import path2 from "path";
-import chalk14 from "chalk";
+import chalk15 from "chalk";
 
 // src/commands/db/utils/metadata.ts
 import { promises as fs } from "fs";
 import path from "path";
 import { promisify } from "util";
 import { exec } from "child_process";
-import chalk13 from "chalk";
+import chalk14 from "chalk";
 var execAsync = promisify(exec);
 async function collectGitInfo() {
   try {
@@ -2251,7 +2687,7 @@ async function collectMigrationInfo(dbUrl) {
       await pool.end();
     }
   } catch (error) {
-    console.log(chalk13.dim("\u26A0\uFE0F  Could not fetch migration info"));
+    console.log(chalk14.dim("\u26A0\uFE0F  Could not fetch migration info"));
     return void 0;
   }
 }
@@ -2259,9 +2695,9 @@ async function saveBackupMetadata(metadata, backupFilename) {
   const metadataPath = backupFilename.replace(/\.(sql|dump)$/, ".meta.json");
   try {
     await fs.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
-    console.log(chalk13.dim(`\u2713 Metadata saved: ${path.basename(metadataPath)}`));
+    console.log(chalk14.dim(`\u2713 Metadata saved: ${path.basename(metadataPath)}`));
   } catch (error) {
-    console.log(chalk13.dim("\u26A0\uFE0F  Could not save metadata"));
+    console.log(chalk14.dim("\u26A0\uFE0F  Could not save metadata"));
   }
 }
 async function loadBackupMetadata(backupFilename) {
@@ -2290,10 +2726,10 @@ async function ensureBackupInGitignore() {
     if (!hasBackupsIgnore) {
       const entry = exists && content && !content.endsWith("\n") ? "\n\n# Database backups\nbackups/\n" : "# Database backups\nbackups/\n";
       await fs2.appendFile(gitignorePath, entry);
-      console.log(chalk14.dim("\u2713 Added backups/ to .gitignore"));
+      console.log(chalk15.dim("\u2713 Added backups/ to .gitignore"));
     }
   } catch (error) {
-    console.log(chalk14.dim("\u26A0\uFE0F  Could not update .gitignore"));
+    console.log(chalk15.dim("\u26A0\uFE0F  Could not update .gitignore"));
   }
 }
 async function ensureBackupDir() {
@@ -2341,12 +2777,14 @@ async function listBackupFiles() {
 
 // src/commands/db/backup.ts
 import { env as env3 } from "@spfn/core/config";
+import { loadEnv as loadEnv4 } from "@spfn/core/server";
 async function dbBackup(options) {
-  console.log(chalk15.blue("\u{1F4BE} Creating database backup...\n"));
+  console.log(chalk16.blue("\u{1F4BE} Creating database backup...\n"));
+  loadEnv4();
   const dbUrl = env3.DATABASE_URL;
   if (!dbUrl) {
-    console.error(chalk15.red("\u274C DATABASE_URL not found in environment"));
-    console.log(chalk15.yellow("\n\u{1F4A1} Tip: Add DATABASE_URL to your .env file"));
+    console.error(chalk16.red("\u274C DATABASE_URL not found in environment"));
+    console.log(chalk16.yellow("\n\u{1F4A1} Tip: Add DATABASE_URL to your .env file"));
     process.exit(1);
   }
   const dbInfo = parseDatabaseUrl(dbUrl);
@@ -2356,7 +2794,7 @@ async function dbBackup(options) {
   const ext = format === "sql" ? "sql" : "dump";
   const filename = options.output || path3.join(backupDir, `${dbInfo.database}_${timestamp}.${ext}`);
   if (options.dataOnly && options.schemaOnly) {
-    console.error(chalk15.red("\u274C Cannot use --data-only and --schema-only together"));
+    console.error(chalk16.red("\u274C Cannot use --data-only and --schema-only together"));
     process.exit(1);
   }
   const args = [
@@ -2402,11 +2840,11 @@ async function dbBackup(options) {
           const stats = await fs3.stat(filename);
           const size = formatBytes(stats.size);
           spinner.succeed("Backup created");
-          console.log(chalk15.green(`
+          console.log(chalk16.green(`
 \u2705 Backup created successfully`));
-          console.log(chalk15.gray(`   File: ${filename}`));
-          console.log(chalk15.gray(`   Size: ${size}`));
-          console.log(chalk15.dim("\n\u{1F4CB} Collecting metadata..."));
+          console.log(chalk16.gray(`   File: ${filename}`));
+          console.log(chalk16.gray(`   Size: ${size}`));
+          console.log(chalk16.dim("\n\u{1F4CB} Collecting metadata..."));
           const [gitInfo, migrationInfo] = await Promise.all([
             collectGitInfo(),
             collectMigrationInfo(dbUrl)
@@ -2446,18 +2884,20 @@ async function dbBackup(options) {
       reject(error);
     });
   }).catch((error) => {
-    console.error(chalk15.red("\n\u274C Failed to create backup"));
+    console.error(chalk16.red("\n\u274C Failed to create backup"));
     if (errorOutput.includes("pg_dump: command not found") || errorOutput.includes("not found")) {
-      console.error(chalk15.yellow("\n\u{1F4A1} pg_dump is not installed. Please install PostgreSQL client tools."));
+      console.error(chalk16.yellow("\n\u{1F4A1} pg_dump is not installed. Please install PostgreSQL client tools."));
     } else {
-      console.error(chalk15.red(error instanceof Error ? error.message : "Unknown error"));
+      console.error(chalk16.red(error instanceof Error ? error.message : "Unknown error"));
     }
     process.exit(1);
   });
 }
 
 // src/commands/db/migrate.ts
-import "@spfn/core/config";
+import { env as env4 } from "@spfn/core/config";
+import { loadEnv as loadEnv5 } from "@spfn/core/server";
+var PROJECT_MIGRATIONS_TABLE = "__drizzle_migrations";
 async function dbMigrate(options = {}) {
   try {
     validateDatabasePrerequisites();
@@ -2465,7 +2905,7 @@ async function dbMigrate(options = {}) {
     process.exit(1);
   }
   if (options.withBackup) {
-    console.log(chalk16.blue("\u{1F4E6} Creating pre-migration backup...\n"));
+    console.log(chalk17.blue("\u{1F4E6} Creating pre-migration backup...\n"));
     await dbBackup({
       format: "custom",
       tag: "pre-migration",
@@ -2473,59 +2913,72 @@ async function dbMigrate(options = {}) {
     });
     console.log("");
   }
+  const { drizzle } = await import("drizzle-orm/postgres-js");
+  const { migrate } = await import("drizzle-orm/postgres-js/migrator");
+  const postgres = await import("postgres");
+  loadEnv5();
+  if (!env4.DATABASE_URL) {
+    console.error(chalk17.red("\u274C DATABASE_URL not found in environment"));
+    process.exit(1);
+  }
   const { discoverFunctionMigrations: discoverFunctionMigrations2, executeFunctionMigrations: executeFunctionMigrations2 } = await Promise.resolve().then(() => (init_function_migrations(), function_migrations_exports));
   const functions = discoverFunctionMigrations2(process.cwd());
   if (functions.length > 0) {
-    console.log(chalk16.blue("\u{1F4E6} Applying function package migrations:"));
+    console.log(chalk17.blue("\u{1F4E6} Applying function package migrations:"));
     functions.forEach((func) => {
-      console.log(chalk16.dim(`  - ${func.packageName}`));
+      console.log(chalk17.dim(`  - ${func.packageName}`));
     });
+    await executeFunctionMigrations2(functions);
+    console.log(chalk17.green("\u2705 Function migrations applied\n"));
+  }
+  const projectMigrationsDir = join16(process.cwd(), "src/server/drizzle");
+  if (existsSync18(projectMigrationsDir)) {
+    const projConn = postgres.default(env4.DATABASE_URL, { max: 1 });
+    const projDb = drizzle(projConn);
     try {
-      await executeFunctionMigrations2(functions);
-      console.log(chalk16.green("\u2705 Function migrations applied\n"));
-    } catch (error) {
-      console.error(chalk16.red("\n\u274C Failed to apply function migrations"));
-      console.error(chalk16.red(error instanceof Error ? error.message : "Unknown error"));
-      process.exit(1);
+      console.log(chalk17.blue("\u{1F4E6} Running project migrations..."));
+      await migrate(projDb, {
+        migrationsFolder: projectMigrationsDir,
+        migrationsTable: PROJECT_MIGRATIONS_TABLE
+      });
+      console.log(chalk17.green("\u2705 Project migrations applied successfully"));
+    } finally {
+      await projConn.end();
     }
+  } else {
+    console.log(chalk17.dim("No project migrations found (src/server/drizzle)"));
   }
-  await runWithSpinner(
-    "Running project migrations...",
-    "migrate",
-    "Project migrations applied successfully",
-    "Failed to run project migrations"
-  );
 }
 
 // src/commands/db/studio.ts
-import chalk17 from "chalk";
-import { existsSync as existsSync18, writeFileSync as writeFileSync10, unlinkSync as unlinkSync2 } from "fs";
+import chalk18 from "chalk";
+import { existsSync as existsSync19, writeFileSync as writeFileSync10, unlinkSync as unlinkSync3 } from "fs";
 import { spawn as spawn3 } from "child_process";
-import { env as env4 } from "@spfn/core/config";
+import { env as env5 } from "@spfn/core/config";
 import "@spfn/core/config";
 async function dbStudio(requestedPort) {
-  console.log(chalk17.blue("\u{1F3A8} Opening Drizzle Studio...\n"));
+  console.log(chalk18.blue("\u{1F3A8} Opening Drizzle Studio...\n"));
   const defaultPort = 4983;
   const startPort = requestedPort || defaultPort;
   let port;
   try {
     port = await findAvailablePort(startPort);
     if (port !== startPort) {
-      console.log(chalk17.yellow(`\u26A0\uFE0F  Port ${startPort} is in use, using port ${port} instead
+      console.log(chalk18.yellow(`\u26A0\uFE0F  Port ${startPort} is in use, using port ${port} instead
 `));
     }
   } catch (error) {
-    console.error(chalk17.red(error instanceof Error ? error.message : "Failed to find available port"));
+    console.error(chalk18.red(error instanceof Error ? error.message : "Failed to find available port"));
     process.exit(1);
   }
-  const hasUserConfig = existsSync18("./drizzle.config.ts");
+  const hasUserConfig = existsSync19("./drizzle.config.ts");
   const tempConfigPath = `./drizzle.config.${process.pid}.${Date.now()}.temp.ts`;
   try {
     const configPath = hasUserConfig ? "./drizzle.config.ts" : tempConfigPath;
     if (!hasUserConfig) {
-      if (!env4.DATABASE_URL) {
-        console.error(chalk17.red("\u274C DATABASE_URL not found in environment"));
-        console.log(chalk17.yellow("\n\u{1F4A1} Tip: Add DATABASE_URL to your .env file"));
+      if (!env5.DATABASE_URL) {
+        console.error(chalk18.red("\u274C DATABASE_URL not found in environment"));
+        console.log(chalk18.yellow("\n\u{1F4A1} Tip: Add DATABASE_URL to your .env file"));
         process.exit(1);
       }
       const { generateDrizzleConfigFile } = await import("@spfn/core/db");
@@ -2536,33 +2989,34 @@ async function dbStudio(requestedPort) {
         // Expand glob patterns for Studio compatibility
       });
       writeFileSync10(tempConfigPath, configContent);
-      console.log(chalk17.dim("Using auto-generated Drizzle config\n"));
+      console.log(chalk18.dim("Using auto-generated Drizzle config\n"));
     }
     const studioProcess = spawn3("drizzle-kit", ["studio", `--port=${port}`, `--config=${configPath}`], {
       stdio: "inherit",
-      shell: true
+      shell: true,
+      env: { ...process.env, NODE_TLS_REJECT_UNAUTHORIZED: "0" }
     });
     const cleanup = () => {
-      if (!hasUserConfig && existsSync18(tempConfigPath)) {
-        unlinkSync2(tempConfigPath);
+      if (!hasUserConfig && existsSync19(tempConfigPath)) {
+        unlinkSync3(tempConfigPath);
       }
     };
     studioProcess.on("exit", (code) => {
       cleanup();
       if (code !== 0 && code !== null) {
-        console.error(chalk17.red(`
+        console.error(chalk18.red(`
 \u274C Drizzle Studio exited with code ${code}`));
         process.exit(code);
       }
     });
     studioProcess.on("error", (error) => {
       cleanup();
-      console.error(chalk17.red("\u274C Failed to start Drizzle Studio"));
-      console.error(chalk17.red(error.message));
+      console.error(chalk18.red("\u274C Failed to start Drizzle Studio"));
+      console.error(chalk18.red(error.message));
       process.exit(1);
     });
     process.on("SIGINT", () => {
-      console.log(chalk17.yellow("\n\n\u{1F44B} Shutting down Drizzle Studio..."));
+      console.log(chalk18.yellow("\n\n\u{1F44B} Shutting down Drizzle Studio..."));
       studioProcess.kill("SIGTERM");
       cleanup();
       process.exit(0);
@@ -2573,28 +3027,28 @@ async function dbStudio(requestedPort) {
       process.exit(0);
     });
   } catch (error) {
-    if (!hasUserConfig && existsSync18(tempConfigPath)) {
-      unlinkSync2(tempConfigPath);
+    if (!hasUserConfig && existsSync19(tempConfigPath)) {
+      unlinkSync3(tempConfigPath);
     }
-    console.error(chalk17.red("\u274C Failed to start Drizzle Studio"));
-    console.error(chalk17.red(error instanceof Error ? error.message : "Unknown error"));
+    console.error(chalk18.red("\u274C Failed to start Drizzle Studio"));
+    console.error(chalk18.red(error instanceof Error ? error.message : "Unknown error"));
     process.exit(1);
   }
 }
 
 // src/commands/db/drop.ts
-import chalk18 from "chalk";
-import prompts3 from "prompts";
+import chalk19 from "chalk";
+import prompts4 from "prompts";
 async function dbDrop() {
-  console.log(chalk18.yellow("\u26A0\uFE0F  WARNING: This will drop all tables in your database!"));
-  const { confirm } = await prompts3({
+  console.log(chalk19.yellow("\u26A0\uFE0F  WARNING: This will drop all tables in your database!"));
+  const { confirm } = await prompts4({
     type: "confirm",
     name: "confirm",
     message: "Are you sure you want to drop all tables?",
     initial: false
   });
   if (!confirm) {
-    console.log(chalk18.gray("Cancelled."));
+    console.log(chalk19.gray("Cancelled."));
     process.exit(0);
   }
   await runWithSpinner(
@@ -2606,7 +3060,7 @@ async function dbDrop() {
 }
 
 // src/commands/db/check.ts
-import chalk19 from "chalk";
+import chalk20 from "chalk";
 import ora8 from "ora";
 async function dbCheck() {
   const spinner = ora8("Checking database connection...").start();
@@ -2615,7 +3069,7 @@ async function dbCheck() {
     spinner.succeed("Database connection OK");
   } catch (error) {
     spinner.fail("Database connection failed");
-    console.error(chalk19.red(error instanceof Error ? error.message : "Unknown error"));
+    console.error(chalk20.red(error instanceof Error ? error.message : "Unknown error"));
     process.exit(1);
   }
 }
@@ -2623,26 +3077,28 @@ async function dbCheck() {
 // src/commands/db/restore.ts
 import path4 from "path";
 import { spawn as spawn4 } from "child_process";
-import chalk20 from "chalk";
+import chalk21 from "chalk";
 import ora9 from "ora";
-import prompts4 from "prompts";
-import { env as env5 } from "@spfn/core/config";
+import prompts5 from "prompts";
+import { env as env6 } from "@spfn/core/config";
+import { loadEnv as loadEnv6 } from "@spfn/core/server";
 async function dbRestore(backupFile, options = {}) {
-  console.log(chalk20.blue("\u267B\uFE0F  Restoring database from backup...\n"));
-  const dbUrl = env5.DATABASE_URL;
+  console.log(chalk21.blue("\u267B\uFE0F  Restoring database from backup...\n"));
+  loadEnv6();
+  const dbUrl = env6.DATABASE_URL;
   if (!dbUrl) {
-    console.error(chalk20.red("\u274C DATABASE_URL not found in environment"));
-    console.log(chalk20.yellow("\n\u{1F4A1} Tip: Add DATABASE_URL to your .env file"));
+    console.error(chalk21.red("\u274C DATABASE_URL not found in environment"));
+    console.log(chalk21.yellow("\n\u{1F4A1} Tip: Add DATABASE_URL to your .env file"));
     process.exit(1);
   }
   let file = backupFile;
   if (!file) {
     const backups = await listBackupFiles();
     if (backups.length === 0) {
-      console.log(chalk20.yellow("No backups found in ./backups directory"));
+      console.log(chalk21.yellow("No backups found in ./backups directory"));
       process.exit(0);
     }
-    const { selected } = await prompts4({
+    const { selected } = await prompts5({
       type: "select",
       name: "selected",
       message: "Select backup to restore:",
@@ -2652,70 +3108,70 @@ async function dbRestore(backupFile, options = {}) {
       }))
     });
     if (!selected) {
-      console.log(chalk20.gray("Cancelled"));
+      console.log(chalk21.gray("Cancelled"));
       process.exit(0);
     }
     file = selected;
   }
   if (!file) {
-    console.error(chalk20.red("\u274C No backup file selected"));
+    console.error(chalk21.red("\u274C No backup file selected"));
     process.exit(1);
   }
   const metadata = await loadBackupMetadata(file);
   if (metadata) {
-    console.log(chalk20.blue("\n\u{1F4CB} Backup Information:\n"));
-    console.log(chalk20.dim(`  Database: ${metadata.database}`));
-    console.log(chalk20.dim(`  Created: ${new Date(metadata.timestamp).toLocaleString()}`));
+    console.log(chalk21.blue("\n\u{1F4CB} Backup Information:\n"));
+    console.log(chalk21.dim(`  Database: ${metadata.database}`));
+    console.log(chalk21.dim(`  Created: ${new Date(metadata.timestamp).toLocaleString()}`));
     if (metadata.environment) {
-      console.log(chalk20.dim(`  Environment: ${metadata.environment}`));
+      console.log(chalk21.dim(`  Environment: ${metadata.environment}`));
     }
     if (metadata.tags && metadata.tags.length > 0) {
-      console.log(chalk20.dim(`  Tags: ${metadata.tags.join(", ")}`));
+      console.log(chalk21.dim(`  Tags: ${metadata.tags.join(", ")}`));
     }
     if (metadata.backup.dataOnly) {
-      console.log(chalk20.yellow("  \u26A0\uFE0F  Data-only backup (no schema)"));
+      console.log(chalk21.yellow("  \u26A0\uFE0F  Data-only backup (no schema)"));
     }
     if (metadata.backup.schemaOnly) {
-      console.log(chalk20.yellow("  \u26A0\uFE0F  Schema-only backup (no data)"));
+      console.log(chalk21.yellow("  \u26A0\uFE0F  Schema-only backup (no data)"));
     }
-    const warnings = [];
+    const warnings2 = [];
     const [currentGitInfo, currentMigrationInfo] = await Promise.all([
       collectGitInfo(),
       collectMigrationInfo(dbUrl)
     ]);
     if (metadata.git && currentGitInfo) {
       if (metadata.git.commit !== currentGitInfo.commit) {
-        warnings.push(`Git commit mismatch: backup from ${metadata.git.commit.substring(0, 7)}, current is ${currentGitInfo.commit.substring(0, 7)}`);
+        warnings2.push(`Git commit mismatch: backup from ${metadata.git.commit.substring(0, 7)}, current is ${currentGitInfo.commit.substring(0, 7)}`);
       }
       if (metadata.git.branch !== currentGitInfo.branch) {
-        warnings.push(`Git branch mismatch: backup from '${metadata.git.branch}', current is '${currentGitInfo.branch}'`);
+        warnings2.push(`Git branch mismatch: backup from '${metadata.git.branch}', current is '${currentGitInfo.branch}'`);
       }
     }
     if (metadata.migrations && currentMigrationInfo) {
       if (metadata.migrations.hash !== currentMigrationInfo.hash) {
-        warnings.push(`Migration version mismatch: backup has ${metadata.migrations.count} migrations, current has ${currentMigrationInfo.count}`);
-        warnings.push(`  Last migration in backup: ${metadata.migrations.hash}`);
-        warnings.push(`  Current last migration: ${currentMigrationInfo.hash}`);
+        warnings2.push(`Migration version mismatch: backup has ${metadata.migrations.count} migrations, current has ${currentMigrationInfo.count}`);
+        warnings2.push(`  Last migration in backup: ${metadata.migrations.hash}`);
+        warnings2.push(`  Current last migration: ${currentMigrationInfo.hash}`);
       }
     }
-    if (warnings.length > 0) {
-      console.log(chalk20.yellow("\n\u26A0\uFE0F  Version Warnings:\n"));
-      warnings.forEach((warning) => console.log(chalk20.yellow(`  - ${warning}`)));
+    if (warnings2.length > 0) {
+      console.log(chalk21.yellow("\n\u26A0\uFE0F  Version Warnings:\n"));
+      warnings2.forEach((warning) => console.log(chalk21.yellow(`  - ${warning}`)));
       console.log("");
     }
   }
-  const { confirm } = await prompts4({
+  const { confirm } = await prompts5({
     type: "confirm",
     name: "confirm",
-    message: chalk20.yellow("\u26A0\uFE0F  This will replace all data in the database. Continue?"),
+    message: chalk21.yellow("\u26A0\uFE0F  This will replace all data in the database. Continue?"),
     initial: false
   });
   if (!confirm) {
-    console.log(chalk20.gray("Cancelled"));
+    console.log(chalk21.gray("Cancelled"));
     process.exit(0);
   }
   if (options.dataOnly && options.schemaOnly) {
-    console.error(chalk20.red("\u274C Cannot use --data-only and --schema-only together"));
+    console.error(chalk21.red("\u274C Cannot use --data-only and --schema-only together"));
     process.exit(1);
   }
   const dbInfo = parseDatabaseUrl(dbUrl);
@@ -2728,6 +3184,7 @@ async function dbRestore(backupFile, options = {}) {
     args.push("-p", dbInfo.port);
     args.push("-U", dbInfo.user);
     args.push("-d", dbInfo.database);
+    args.push("--verbose");
     if (options.drop) {
       args.push("--clean");
     }
@@ -2743,15 +3200,17 @@ async function dbRestore(backupFile, options = {}) {
     args.push(file);
   } else {
     if (options.dataOnly || options.schemaOnly) {
-      console.log(chalk20.yellow("\u26A0\uFE0F  Note: --data-only and --schema-only options only work with custom format backups (.dump)"));
-      console.log(chalk20.yellow("    For SQL files, the backup must have been created with the desired option.\n"));
+      console.log(chalk21.yellow("\u26A0\uFE0F  Note: --data-only and --schema-only options only work with custom format backups (.dump)"));
+      console.log(chalk21.yellow("    For SQL files, the backup must have been created with the desired option.\n"));
     }
     args.push("-h", dbInfo.host);
     args.push("-p", dbInfo.port);
     args.push("-U", dbInfo.user);
     args.push("-d", dbInfo.database);
+    args.push("-v", "ON_ERROR_STOP=1");
     args.push("-f", file);
   }
+  const verbose = options.verbose ?? false;
   const spinner = ora9("Restoring backup...").start();
   const restoreProcess = spawn4(command, args, {
     stdio: ["ignore", "pipe", "pipe"],
@@ -2760,19 +3219,81 @@ async function dbRestore(backupFile, options = {}) {
       PGPASSWORD: dbInfo.password
     }
   });
-  let errorOutput = "";
+  const warnings = [];
+  const errors = [];
+  let objectCount = 0;
+  let lastObject = "";
   restoreProcess.stderr?.on("data", (data) => {
-    errorOutput += data.toString();
+    const lines = data.toString().split("\n").filter((l) => l.trim());
+    for (const line of lines) {
+      if (/^pg_restore:.*warning:/i.test(line) || /^WARNING:/i.test(line)) {
+        warnings.push(line.trim());
+      } else if (/^pg_restore:.*error:/i.test(line) || /^ERROR:/i.test(line) || /^psql:.*ERROR/i.test(line)) {
+        errors.push(line.trim());
+      }
+      const objectMatch = line.match(/processing item (\d+)\/(\d+)/);
+      if (objectMatch) {
+        objectCount = Number(objectMatch[2]);
+        const current = Number(objectMatch[1]);
+        const desc = line.replace(/^pg_restore:\s*/, "").trim();
+        lastObject = desc;
+        spinner.text = `Restoring backup... [${current}/${objectCount}] ${desc}`;
+      } else if (isCustomFormat) {
+        const desc = line.replace(/^pg_restore:\s*/, "").trim();
+        if (desc && !/warning:|error:/i.test(desc)) {
+          lastObject = desc;
+          spinner.text = `Restoring backup... ${desc}`;
+        }
+      }
+      if (verbose) {
+        spinner.stop();
+        console.log(chalk21.dim(`  ${line.trim()}`));
+        spinner.start();
+      }
+    }
+  });
+  restoreProcess.stdout?.on("data", (data) => {
+    if (verbose) {
+      spinner.stop();
+      console.log(chalk21.dim(`  ${data.toString().trim()}`));
+      spinner.start();
+    }
   });
   await new Promise((resolve2, reject) => {
     restoreProcess.on("close", (code) => {
       if (code === 0) {
-        spinner.succeed("Restore completed");
-        console.log(chalk20.green("\n\u2705 Database restored successfully"));
+        const summary = objectCount > 0 ? ` (${objectCount} objects)` : "";
+        spinner.succeed(`Restore completed${summary}`);
+        if (warnings.length > 0) {
+          console.log(chalk21.yellow(`
+\u26A0\uFE0F  Warnings during restore (${warnings.length}):
+`));
+          for (const w of warnings) {
+            console.log(chalk21.yellow(`  - ${w}`));
+          }
+        }
+        console.log(chalk21.green("\n\u2705 Database restored successfully"));
         resolve2();
       } else {
         spinner.fail("Restore failed");
-        reject(new Error(errorOutput || "Restore failed"));
+        if (errors.length > 0) {
+          console.error(chalk21.red(`
+\u274C Errors (${errors.length}):
+`));
+          for (const e of errors) {
+            console.error(chalk21.red(`  - ${e}`));
+          }
+        }
+        if (warnings.length > 0) {
+          console.log(chalk21.yellow(`
+\u26A0\uFE0F  Warnings (${warnings.length}):
+`));
+          for (const w of warnings) {
+            console.log(chalk21.yellow(`  - ${w}`));
+          }
+        }
+        const fallback = errors.length === 0 && warnings.length === 0 ? "Restore failed with no output" : "";
+        reject(new Error(fallback));
       }
     });
     restoreProcess.on("error", (error) => {
@@ -2780,24 +3301,27 @@ async function dbRestore(backupFile, options = {}) {
       reject(error);
     });
   }).catch((error) => {
-    console.error(chalk20.red("\n\u274C Failed to restore database"));
-    console.error(chalk20.red(error instanceof Error ? error.message : "Unknown error"));
+    const msg = error instanceof Error ? error.message : "Unknown error";
+    if (msg) {
+      console.error(chalk21.red(`
+\u274C ${msg}`));
+    }
     process.exit(1);
   });
 }
 
 // src/commands/db/list.ts
-import chalk21 from "chalk";
+import chalk22 from "chalk";
 async function dbBackupList() {
-  console.log(chalk21.blue("\u{1F4CB} Database backups:\n"));
+  console.log(chalk22.blue("\u{1F4CB} Database backups:\n"));
   const backups = await listBackupFiles();
   if (backups.length === 0) {
-    console.log(chalk21.yellow("No backups found in ./backups directory"));
-    console.log(chalk21.gray("\n\u{1F4A1} Create a backup with: pnpm spfn db backup\n"));
+    console.log(chalk22.yellow("No backups found in ./backups directory"));
+    console.log(chalk22.gray("\n\u{1F4A1} Create a backup with: pnpm spfn db backup\n"));
     return;
   }
-  console.log(chalk21.bold("  Date                  Size        File"));
-  console.log(chalk21.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(chalk22.bold("  Date                  Size        File"));
+  console.log(chalk22.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   backups.forEach((backup) => {
     const date = backup.date.toLocaleString("en-US", {
       year: "numeric",
@@ -2808,23 +3332,23 @@ async function dbBackupList() {
       second: "2-digit"
     });
     const sizeStr = backup.size.padEnd(10);
-    console.log(chalk21.white(`  ${date}  ${sizeStr}  ${backup.name}`));
+    console.log(chalk22.white(`  ${date}  ${sizeStr}  ${backup.name}`));
   });
-  console.log(chalk21.gray(`
+  console.log(chalk22.gray(`
   Total: ${backups.length} backup(s)
 `));
 }
 
 // src/commands/db/clean.ts
 import { promises as fs4 } from "fs";
-import chalk22 from "chalk";
+import chalk23 from "chalk";
 import ora10 from "ora";
-import prompts5 from "prompts";
+import prompts6 from "prompts";
 async function dbBackupClean(options) {
-  console.log(chalk22.blue("\u{1F9F9} Cleaning old backups...\n"));
+  console.log(chalk23.blue("\u{1F9F9} Cleaning old backups...\n"));
   const backups = await listBackupFiles();
   if (backups.length === 0) {
-    console.log(chalk22.yellow("No backups found"));
+    console.log(chalk23.yellow("No backups found"));
     return;
   }
   let toDelete = [];
@@ -2841,74 +3365,176 @@ async function dbBackupClean(options) {
     toDelete = backups.slice(defaultKeep);
   }
   if (toDelete.length === 0) {
-    console.log(chalk22.green("\u2705 No backups to clean"));
+    console.log(chalk23.green("\u2705 No backups to clean"));
     return;
   }
-  console.log(chalk22.yellow(`The following ${toDelete.length} backup(s) will be deleted:
+  console.log(chalk23.yellow(`The following ${toDelete.length} backup(s) will be deleted:
 `));
   toDelete.forEach((backup) => {
-    console.log(chalk22.gray(`  - ${backup.name} (${backup.size})`));
+    console.log(chalk23.gray(`  - ${backup.name} (${backup.size})`));
   });
-  const { confirm } = await prompts5({
+  const { confirm } = await prompts6({
     type: "confirm",
     name: "confirm",
     message: "\nProceed with deletion?",
     initial: false
   });
   if (!confirm) {
-    console.log(chalk22.gray("Cancelled"));
+    console.log(chalk23.gray("Cancelled"));
     return;
   }
   const spinner = ora10("Deleting backups...").start();
   try {
     await Promise.all(toDelete.map((backup) => fs4.unlink(backup.path)));
     spinner.succeed("Backups deleted");
-    console.log(chalk22.green(`
+    console.log(chalk23.green(`
 \u2705 Deleted ${toDelete.length} backup(s)`));
   } catch (error) {
     spinner.fail("Failed to delete backups");
-    console.error(chalk22.red(error instanceof Error ? error.message : "Unknown error"));
+    console.error(chalk23.red(error instanceof Error ? error.message : "Unknown error"));
     process.exit(1);
   }
 }
 
+// src/commands/db/reindex.ts
+import { existsSync as existsSync20, readFileSync as readFileSync6, writeFileSync as writeFileSync11, renameSync, copyFileSync } from "fs";
+import { join as join17 } from "path";
+import chalk24 from "chalk";
+import { loadEnv as loadEnv7 } from "@spfn/core/server";
+function isTimestampPrefix(tag) {
+  const prefix = tag.split("_")[0];
+  return /^\d{5,}$/.test(prefix);
+}
+function parseTag(tag) {
+  const underscoreIdx = tag.indexOf("_");
+  if (underscoreIdx === -1) {
+    return { prefix: tag, suffix: "" };
+  }
+  return {
+    prefix: tag.substring(0, underscoreIdx),
+    suffix: tag.substring(underscoreIdx + 1)
+  };
+}
+async function dbReindex(options = {}) {
+  loadEnv7();
+  const { getDrizzleConfig } = await import("@spfn/core/db");
+  const config = getDrizzleConfig({ disablePackageDiscovery: true });
+  const outDir = config.out;
+  const journalPath = join17(outDir, "meta", "_journal.json");
+  if (!existsSync20(journalPath)) {
+    console.error(chalk24.red("\u274C No _journal.json found at:"), journalPath);
+    console.log(chalk24.yellow("\u{1F4A1} Run `spfn db generate` first to create migrations"));
+    process.exit(1);
+  }
+  const journal = JSON.parse(readFileSync6(journalPath, "utf-8"));
+  if (journal.entries.length === 0) {
+    console.log(chalk24.yellow("No migration entries found \u2014 nothing to reindex."));
+    return;
+  }
+  const renames = [];
+  const tagUpdates = [];
+  let skipped = 0;
+  for (const entry of journal.entries) {
+    if (isTimestampPrefix(entry.tag)) {
+      skipped++;
+      continue;
+    }
+    const { prefix: oldPrefix, suffix } = parseTag(entry.tag);
+    const newPrefix = String(entry.when);
+    const newTag = suffix ? `${newPrefix}_${suffix}` : newPrefix;
+    const oldSql = join17(outDir, `${entry.tag}.sql`);
+    const newSql = join17(outDir, `${newTag}.sql`);
+    if (existsSync20(oldSql)) {
+      renames.push({ type: "sql", from: oldSql, to: newSql });
+    }
+    const oldSnapshot = join17(outDir, "meta", `${oldPrefix}_snapshot.json`);
+    const newSnapshot = join17(outDir, "meta", `${newPrefix}_snapshot.json`);
+    if (existsSync20(oldSnapshot)) {
+      renames.push({ type: "snapshot", from: oldSnapshot, to: newSnapshot });
+    }
+    tagUpdates.push({ idx: entry.idx, oldTag: entry.tag, newTag });
+  }
+  if (tagUpdates.length === 0) {
+    console.log(chalk24.green("\u2705 All migrations already use timestamp prefix \u2014 nothing to do."));
+    if (skipped > 0) {
+      console.log(chalk24.dim(`   (${skipped} entries already timestamp-prefixed)`));
+    }
+    return;
+  }
+  console.log(chalk24.bold("\n\u{1F4CB} Reindex plan:\n"));
+  for (const update of tagUpdates) {
+    console.log(
+      chalk24.dim(`  [${update.idx}]`),
+      chalk24.red(update.oldTag),
+      chalk24.dim("\u2192"),
+      chalk24.green(update.newTag)
+    );
+  }
+  console.log(chalk24.dim(`
+  ${renames.length} file(s) to rename, ${tagUpdates.length} journal tag(s) to update`));
+  if (skipped > 0) {
+    console.log(chalk24.dim(`  ${skipped} entry/entries already timestamp-prefixed (skipped)`));
+  }
+  if (options.dryRun) {
+    console.log(chalk24.yellow("\n\u{1F50D} Dry run \u2014 no changes applied."));
+    return;
+  }
+  const backupPath = journalPath + ".bak";
+  copyFileSync(journalPath, backupPath);
+  console.log(chalk24.dim(`
+  Backed up journal \u2192 ${backupPath}`));
+  for (const rename of renames) {
+    renameSync(rename.from, rename.to);
+  }
+  for (const update of tagUpdates) {
+    const entry = journal.entries.find((e) => e.idx === update.idx);
+    if (entry) {
+      entry.tag = update.newTag;
+    }
+  }
+  writeFileSync11(journalPath, JSON.stringify(journal, null, 2) + "\n");
+  console.log(chalk24.green(`
+\u2705 Reindex complete \u2014 ${tagUpdates.length} migration(s) converted to timestamp prefix.`));
+}
+
 // src/commands/db/index.ts
 var dbCommand = new Command9("db").description("Database management commands (wraps Drizzle Kit)");
 dbCommand.command("generate").alias("g").description("Generate database migrations from schema changes").action(dbGenerate);
-dbCommand.command("push").description("Push schema changes directly to database (no migrations)").action(dbPush);
+dbCommand.command("push").description("Push schema changes to database (safe mode by default)").option("--force", "Apply all changes including destructive ones").option("--dry-run", "Show changes without applying").action((options) => dbPush(options));
 dbCommand.command("migrate").alias("m").description("Run pending migrations").option("--with-backup", "Create backup before running migrations").action((options) => dbMigrate(options));
 dbCommand.command("studio").description("Open Drizzle Studio (database GUI)").option("-p, --port <port>", "Studio port (auto-finds if in use)").action((options) => dbStudio(options.port ? Number(options.port) : void 0));
 dbCommand.command("drop").description("Drop all database tables (\u26A0\uFE0F  dangerous!)").action(dbDrop);
 dbCommand.command("check").description("Check database connection").action(dbCheck);
 dbCommand.command("backup").description("Create a database backup").option("-f, --format <format>", "Backup format (sql or custom)", "sql").option("-o, --output <path>", "Custom output path").option("-s, --schema <name>", "Backup specific schema only").option("--data-only", "Backup data only (no schema)").option("--schema-only", "Backup schema only (no data)").option("--tag <tags>", "Comma-separated tags for this backup").option("--env <environment>", "Environment label (e.g., production, staging)").action((options) => dbBackup(options));
-dbCommand.command("restore [file]").description("Restore database from backup").option("--drop", "Drop existing tables before restore").option("-s, --schema <name>", "Restore specific schema only").option("--data-only", "Restore data only (requires custom format .dump file)").option("--schema-only", "Restore schema only (requires custom format .dump file)").action((file, options) => dbRestore(file, options));
+dbCommand.command("restore [file]").description("Restore database from backup").option("--drop", "Drop existing tables before restore").option("-s, --schema <name>", "Restore specific schema only").option("--data-only", "Restore data only (requires custom format .dump file)").option("--schema-only", "Restore schema only (requires custom format .dump file)").option("-v, --verbose", "Show detailed restore progress").action((file, options) => dbRestore(file, options));
 dbCommand.command("backup:list").description("List all database backups").action(dbBackupList);
 dbCommand.command("backup:clean").description("Clean old database backups").option("-k, --keep <number>", "Keep N most recent backups", parseInt).option("-o, --older-than <days>", "Delete backups older than N days", parseInt).action((options) => dbBackupClean(options));
+dbCommand.command("reindex").description("Convert migration files from sequential to timestamp prefix").option("--dry-run", "Show changes without applying").action((options) => dbReindex(options));
 
 // src/commands/add.ts
 import { Command as Command10 } from "commander";
-import { existsSync as existsSync19, readFileSync as readFileSync6 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync7 } from "fs";
+import { join as join18 } from "path";
 import { exec as exec2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import chalk23 from "chalk";
+import chalk25 from "chalk";
 import ora11 from "ora";
 var execAsync2 = promisify2(exec2);
 async function addPackage(packageName) {
   if (!packageName.includes("/")) {
-    console.error(chalk23.red("\u274C Please specify full package name"));
-    console.log(chalk23.yellow("\n\u{1F4A1} Examples:"));
-    console.log(chalk23.gray("  pnpm spfn add @spfn/cms"));
-    console.log(chalk23.gray("  pnpm spfn add @mycompany/spfn-analytics"));
+    console.error(chalk25.red("\u274C Please specify full package name"));
+    console.log(chalk25.yellow("\n\u{1F4A1} Examples:"));
+    console.log(chalk25.gray("  pnpm spfn add @spfn/cms"));
+    console.log(chalk25.gray("  pnpm spfn add @mycompany/spfn-analytics"));
     process.exit(1);
   }
-  console.log(chalk23.blue(`
+  console.log(chalk25.blue(`
 \u{1F4E6} Setting up ${packageName}...
 `));
   try {
-    const pkgPath = join16(process.cwd(), "node_modules", ...packageName.split("/"));
-    const pkgJsonPath = join16(pkgPath, "package.json");
-    if (!existsSync19(pkgJsonPath)) {
+    const pkgPath = join18(process.cwd(), "node_modules", ...packageName.split("/"));
+    const pkgJsonPath = join18(pkgPath, "package.json");
+    if (!existsSync21(pkgJsonPath)) {
       const installSpinner = ora11("Installing package...").start();
       try {
         await execAsync2(`pnpm add ${packageName}`);
@@ -2918,21 +3544,21 @@ async function addPackage(packageName) {
         throw error;
       }
     } else {
-      console.log(chalk23.gray("\u2713 Package already installed (using local version)\n"));
+      console.log(chalk25.gray("\u2713 Package already installed (using local version)\n"));
     }
-    if (!existsSync19(pkgJsonPath)) {
+    if (!existsSync21(pkgJsonPath)) {
       throw new Error(`Package ${packageName} not found after installation`);
     }
-    const pkgJson = JSON.parse(readFileSync6(pkgJsonPath, "utf-8"));
+    const pkgJson = JSON.parse(readFileSync7(pkgJsonPath, "utf-8"));
     if (pkgJson.spfn?.migrations) {
-      console.log(chalk23.blue(`
+      console.log(chalk25.blue(`
 \u{1F5C4}\uFE0F  Setting up database for ${packageName}...
 `));
-      const { env: env6 } = await import("@spfn/core/config");
-      if (!env6.DATABASE_URL) {
-        console.log(chalk23.yellow("\u26A0\uFE0F  DATABASE_URL not found"));
-        console.log(chalk23.gray("Skipping database setup. Run migrations manually when ready:\n"));
-        console.log(chalk23.gray(`  pnpm spfn db push
+      const { env: env7 } = await import("@spfn/core/config");
+      if (!env7.DATABASE_URL) {
+        console.log(chalk25.yellow("\u26A0\uFE0F  DATABASE_URL not found"));
+        console.log(chalk25.gray("Skipping database setup. Run migrations manually when ready:\n"));
+        console.log(chalk25.gray(`  pnpm spfn db push
 `));
       } else {
         const { discoverFunctionMigrations: discoverFunctionMigrations2, executeFunctionMigrations: executeFunctionMigrations2 } = await Promise.resolve().then(() => (init_function_migrations(), function_migrations_exports));
@@ -2948,25 +3574,25 @@ async function addPackage(packageName) {
             throw error;
           }
         } else {
-          console.log(chalk23.gray("\u2139\uFE0F  No migrations found for this package"));
+          console.log(chalk25.gray("\u2139\uFE0F  No migrations found for this package"));
         }
       }
     } else {
-      console.log(chalk23.gray("\n\u2139\uFE0F  No database migrations to apply"));
+      console.log(chalk25.gray("\n\u2139\uFE0F  No database migrations to apply"));
     }
-    console.log(chalk23.green(`
+    console.log(chalk25.green(`
 \u2705 ${packageName} installed successfully!
 `));
     if (pkgJson.spfn?.setupMessage) {
-      console.log(chalk23.cyan("\u{1F4DA} Setup Guide:"));
+      console.log(chalk25.cyan("\u{1F4DA} Setup Guide:"));
       console.log(pkgJson.spfn.setupMessage);
       console.log();
     }
   } catch (error) {
-    console.error(chalk23.red(`
+    console.error(chalk25.red(`
 \u274C Failed to install ${packageName}
 `));
-    console.error(chalk23.red(error instanceof Error ? error.message : "Unknown error"));
+    console.error(chalk25.red(error instanceof Error ? error.message : "Unknown error"));
     process.exit(1);
   }
 }
@@ -2976,16 +3602,16 @@ var addCommand = new Command10("add").description("Install and set up SPFN ecosy
 init_logger();
 import { Command as Command11 } from "commander";
 import ora12 from "ora";
-import { join as join25 } from "path";
-import { existsSync as existsSync22 } from "fs";
-import chalk25 from "chalk";
+import { join as join27 } from "path";
+import { existsSync as existsSync24 } from "fs";
+import chalk27 from "chalk";
 
 // src/commands/generate/prompts.ts
 init_logger();
-import prompts6 from "prompts";
-import chalk24 from "chalk";
+import prompts7 from "prompts";
+import chalk26 from "chalk";
 async function promptScope() {
-  const response = await prompts6({
+  const response = await prompts7({
     type: "text",
     name: "scope",
     message: "NPM scope (e.g., @mycompany, @username):",
@@ -3007,7 +3633,7 @@ async function promptScope() {
   return response.scope;
 }
 async function promptFunctionName() {
-  const response = await prompts6({
+  const response = await prompts7({
     type: "text",
     name: "fnName",
     message: "Function name:",
@@ -3028,7 +3654,7 @@ async function promptFunctionName() {
   return response.fnName;
 }
 async function promptDescription(fnName) {
-  const response = await prompts6({
+  const response = await prompts7({
     type: "text",
     name: "description",
     message: "Function description:",
@@ -3037,7 +3663,7 @@ async function promptDescription(fnName) {
   return response.description || "A description of what this module does";
 }
 async function promptEntities() {
-  const response = await prompts6({
+  const response = await prompts7({
     type: "list",
     name: "entities",
     message: "Entity names (comma-separated, press enter to skip):",
@@ -3049,14 +3675,14 @@ async function promptEntities() {
 async function confirmConfiguration(config) {
   const { scope, fnName, description, entities, enableCache, enableRoutes } = config;
   console.log("");
-  logger.info(chalk24.bold("\u26A1 Function Configuration:"));
-  console.log(`  ${chalk24.gray("Package:")}     ${chalk24.cyan(`${scope}/${fnName}`)}`);
-  console.log(`  ${chalk24.gray("Description:")} ${description}`);
-  console.log(`  ${chalk24.gray("Entities:")}    ${entities.length > 0 ? entities.join(", ") : chalk24.gray("none")}`);
-  console.log(`  ${chalk24.gray("Cache:")}       ${enableCache ? chalk24.green("yes") : chalk24.gray("no")}`);
-  console.log(`  ${chalk24.gray("Routes:")}      ${enableRoutes ? chalk24.green("yes") : chalk24.gray("no")}`);
+  logger.info(chalk26.bold("\u26A1 Function Configuration:"));
+  console.log(`  ${chalk26.gray("Package:")}     ${chalk26.cyan(`${scope}/${fnName}`)}`);
+  console.log(`  ${chalk26.gray("Description:")} ${description}`);
+  console.log(`  ${chalk26.gray("Entities:")}    ${entities.length > 0 ? entities.join(", ") : chalk26.gray("none")}`);
+  console.log(`  ${chalk26.gray("Cache:")}       ${enableCache ? chalk26.green("yes") : chalk26.gray("no")}`);
+  console.log(`  ${chalk26.gray("Routes:")}      ${enableRoutes ? chalk26.green("yes") : chalk26.gray("no")}`);
   console.log("");
-  const { confirmed } = await prompts6({
+  const { confirmed } = await prompts7({
     type: "confirm",
     name: "confirmed",
     message: "Create function?",
@@ -3070,12 +3696,12 @@ async function confirmConfiguration(config) {
 }
 
 // src/commands/generate/generators/structure.ts
-import { join as join24 } from "path";
-import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync17 } from "fs";
+import { join as join26 } from "path";
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync18 } from "fs";
 
 // src/commands/generate/generators/config.ts
-import { join as join18 } from "path";
-import { writeFileSync as writeFileSync11, mkdirSync as mkdirSync3 } from "fs";
+import { join as join20 } from "path";
+import { writeFileSync as writeFileSync12, mkdirSync as mkdirSync3 } from "fs";
 
 // src/commands/generate/string-utils.ts
 function toPascalCase(str) {
@@ -3104,30 +3730,30 @@ function toSafeSchemaName(str) {
 }
 
 // src/commands/generate/template-loader.ts
-import { readFileSync as readFileSync7, existsSync as existsSync20 } from "fs";
-import { join as join17, dirname as dirname2 } from "path";
+import { readFileSync as readFileSync8, existsSync as existsSync22 } from "fs";
+import { join as join19, dirname as dirname2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function findTemplatesPath2() {
   const __filename = fileURLToPath2(import.meta.url);
   const __dirname2 = dirname2(__filename);
-  const distPath = join17(__dirname2, "commands", "generate", "templates");
-  if (existsSync20(distPath)) {
+  const distPath = join19(__dirname2, "commands", "generate", "templates");
+  if (existsSync22(distPath)) {
     return distPath;
   }
-  const sameDirPath = join17(__dirname2, "templates");
-  if (existsSync20(sameDirPath)) {
+  const sameDirPath = join19(__dirname2, "templates");
+  if (existsSync22(sameDirPath)) {
     return sameDirPath;
   }
-  const srcPath = join17(__dirname2, "..", "..", "src", "commands", "generate", "templates");
-  if (existsSync20(srcPath)) {
+  const srcPath = join19(__dirname2, "..", "..", "src", "commands", "generate", "templates");
+  if (existsSync22(srcPath)) {
     return srcPath;
   }
   throw new Error(`Templates directory not found. Tried: ${distPath}, ${sameDirPath}, ${srcPath}`);
 }
 function loadTemplate(templateName, variables) {
   const templatesDir = findTemplatesPath2();
-  const templatePath = join17(templatesDir, `${templateName}.template`);
-  let content = readFileSync7(templatePath, "utf-8");
+  const templatePath = join19(templatesDir, `${templateName}.template`);
+  let content = readFileSync8(templatePath, "utf-8");
   for (const [key, value] of Object.entries(variables)) {
     const regex = new RegExp(`\\{\\{${key}\\}\\}`, "g");
     content = content.replace(regex, value);
@@ -3229,8 +3855,8 @@ function generatePackageJson(fnDir, scope, fnName, description) {
       vitest: "^4.0.6"
     }
   };
-  writeFileSync11(
-    join18(fnDir, "package.json"),
+  writeFileSync12(
+    join20(fnDir, "package.json"),
     JSON.stringify(content, null, 4) + "\n"
   );
 }
@@ -3263,8 +3889,8 @@ function generateTsConfig(fnDir) {
     include: ["src/**/*"],
     exclude: ["node_modules", "dist", "**/*.test.ts", "**/__tests__/**"]
   };
-  writeFileSync11(
-    join18(fnDir, "tsconfig.json"),
+  writeFileSync12(
+    join20(fnDir, "tsconfig.json"),
     JSON.stringify(content, null, 4) + "\n"
   );
 }
@@ -3340,7 +3966,7 @@ export default defineConfig({
     ],
 });
 `;
-  writeFileSync11(join18(fnDir, "tsup.config.ts"), content);
+  writeFileSync12(join20(fnDir, "tsup.config.ts"), content);
 }
 function generateDrizzleConfig(fnDir, scope, fnName) {
   const schemaName = `spfn_${toSnakeCase(fnName)}`;
@@ -3360,7 +3986,7 @@ export default defineConfig({
     schemaFilter: ['${schemaName}'], // Only generate for ${fnName} schema
 });
 `;
-  writeFileSync11(join18(fnDir, "drizzle.config.ts"), content);
+  writeFileSync12(join20(fnDir, "drizzle.config.ts"), content);
 }
 function generateExampleGenerator(fnDir, scope, fnName) {
   const pascalName = toPascalCase(fnName);
@@ -3429,10 +4055,10 @@ export const moduleName = '${fnName}';
     };
 }
 `;
-  const generatorsDir = join18(fnDir, "src/server/generators");
+  const generatorsDir = join20(fnDir, "src/server/generators");
   mkdirSync3(generatorsDir, { recursive: true });
-  writeFileSync11(
-    join18(generatorsDir, "example-generator.ts"),
+  writeFileSync12(
+    join20(generatorsDir, "example-generator.ts"),
     content
   );
   const indexContent = `/**
@@ -3446,8 +4072,8 @@ export const moduleName = '${fnName}';
 
 export { create${pascalName}ExampleGenerator } from './example-generator.js';
 `;
-  writeFileSync11(
-    join18(generatorsDir, "index.ts"),
+  writeFileSync12(
+    join20(generatorsDir, "index.ts"),
     indexContent
   );
 }
@@ -3936,15 +4562,15 @@ Contributions are welcome! Please follow the development workflow above.
 
 MIT
 `;
-  writeFileSync11(join18(fnDir, "README.md"), content);
+  writeFileSync12(join20(fnDir, "README.md"), content);
 }
 
 // src/commands/generate/generators/entity.ts
-import { join as join19 } from "path";
-import { writeFileSync as writeFileSync12, existsSync as existsSync21 } from "fs";
+import { join as join21 } from "path";
+import { writeFileSync as writeFileSync13, existsSync as existsSync23 } from "fs";
 function generateSchema(fnDir, scope, fnName) {
-  const schemaFilePath = join19(fnDir, "src/server/entities/schema.ts");
-  if (existsSync21(schemaFilePath)) {
+  const schemaFilePath = join21(fnDir, "src/server/entities/schema.ts");
+  if (existsSync23(schemaFilePath)) {
     return;
   }
   const packageName = `${scope}/${fnName}`;
@@ -3955,7 +4581,7 @@ function generateSchema(fnDir, scope, fnName) {
     PACKAGE_NAME: packageName,
     SCHEMA_VAR_NAME: schemaVarName
   });
-  writeFileSync12(schemaFilePath, content);
+  writeFileSync13(schemaFilePath, content);
 }
 function generateEntity(fnDir, scope, fnName, entityName) {
   const safeScope = toSafeSchemaName(scope);
@@ -3974,8 +4600,8 @@ function generateEntity(fnDir, scope, fnName, entityName) {
     SCHEMA_VAR_NAME: schemaVarName,
     SCHEMA_FILE_NAME: schemaFileName
   });
-  writeFileSync12(
-    join19(fnDir, `src/server/entities/${toKebabCase(entityName)}.ts`),
+  writeFileSync13(
+    join21(fnDir, `src/server/entities/${toKebabCase(entityName)}.ts`),
     content
   );
 }
@@ -3983,12 +4609,12 @@ function generateEntitiesIndex(fnDir, entities) {
   const schemaExport = `export * from './schema';`;
   const entityExports = entities.map((entity) => `export * from './${toKebabCase(entity)}';`).join("\n");
   const content = [schemaExport, entityExports].filter(Boolean).join("\n");
-  writeFileSync12(join19(fnDir, "src/server/entities/index.ts"), content + "\n");
+  writeFileSync13(join21(fnDir, "src/server/entities/index.ts"), content + "\n");
 }
 
 // src/commands/generate/generators/repository.ts
-import { join as join20 } from "path";
-import { writeFileSync as writeFileSync13 } from "fs";
+import { join as join22 } from "path";
+import { writeFileSync as writeFileSync14 } from "fs";
 function generateRepository(fnDir, entityName) {
   const pascalName = toPascalCase(entityName);
   const repoName = `${entityName}Repository`;
@@ -3997,19 +4623,19 @@ function generateRepository(fnDir, entityName) {
     ENTITY_NAME: entityName,
     REPO_NAME: repoName
   });
-  writeFileSync13(
-    join20(fnDir, `src/server/repositories/${toKebabCase(entityName)}.repository.ts`),
+  writeFileSync14(
+    join22(fnDir, `src/server/repositories/${toKebabCase(entityName)}.repository.ts`),
     content
   );
 }
 function generateRepositoriesIndex(fnDir, entities) {
   const exports = entities.map((entity) => `export * from './${toKebabCase(entity)}.repository';`).join("\n");
-  writeFileSync13(join20(fnDir, "src/server/repositories/index.ts"), exports + "\n");
+  writeFileSync14(join22(fnDir, "src/server/repositories/index.ts"), exports + "\n");
 }
 
 // src/commands/generate/generators/route.ts
-import { join as join21 } from "path";
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync14 } from "fs";
+import { join as join23 } from "path";
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync15 } from "fs";
 function generateRoute(fnDir, entityName) {
   const pascalName = toPascalCase(entityName);
   const repoName = `${entityName}Repository`;
@@ -4020,29 +4646,29 @@ function generateRoute(fnDir, entityName) {
     REPO_NAME: repoName,
     KEBAB_NAME: kebabName
   });
-  const routeDir = join21(fnDir, `src/server/routes/${kebabName}`);
+  const routeDir = join23(fnDir, `src/server/routes/${kebabName}`);
   mkdirSync4(routeDir, { recursive: true });
-  writeFileSync14(join21(routeDir, "index.ts"), content);
+  writeFileSync15(join23(routeDir, "index.ts"), content);
 }
 
 // src/commands/generate/generators/contract.ts
-import { join as join22 } from "path";
-import { writeFileSync as writeFileSync15 } from "fs";
+import { join as join24 } from "path";
+import { writeFileSync as writeFileSync16 } from "fs";
 function generateContract(fnDir, entityName) {
   const pascalName = toPascalCase(entityName);
   const content = loadTemplate("contract", {
     PASCAL_NAME: pascalName,
     ENTITY_NAME: entityName
   });
-  writeFileSync15(
-    join22(fnDir, `src/lib/contracts/${toKebabCase(entityName)}.ts`),
+  writeFileSync16(
+    join24(fnDir, `src/lib/contracts/${toKebabCase(entityName)}.ts`),
     content
   );
 }
 
 // src/commands/generate/generators/index-files.ts
-import { join as join23 } from "path";
-import { writeFileSync as writeFileSync16 } from "fs";
+import { join as join25 } from "path";
+import { writeFileSync as writeFileSync17 } from "fs";
 function generateMainIndex(fnDir, fnName) {
   const content = `/**
  * @spfn/${fnName}
@@ -4068,7 +4694,7 @@ export * from '@/lib/types/index';
 
 export * from '@/server/entities/index';
 `;
-  writeFileSync16(join23(fnDir, "src/index.ts"), content);
+  writeFileSync17(join25(fnDir, "src/index.ts"), content);
 }
 function generateServerIndex(fnDir) {
   const content = `/**
@@ -4103,7 +4729,7 @@ export * from '@/server/repositories/index';
 
 // TODO: Export helpers here
 `;
-  writeFileSync16(join23(fnDir, "src/server.ts"), content);
+  writeFileSync17(join25(fnDir, "src/server.ts"), content);
 }
 function generateClientIndex(fnDir) {
   const content = `/**
@@ -4136,7 +4762,7 @@ export * from './client/store';
 
 export * from './client/components';
 `;
-  writeFileSync16(join23(fnDir, "src/client.ts"), content);
+  writeFileSync17(join25(fnDir, "src/client.ts"), content);
 }
 function generateTypesFile(fnDir, fnName) {
   const content = `/**
@@ -4148,7 +4774,7 @@ function generateTypesFile(fnDir, fnName) {
 
 export * from '@/lib/types/index';
 `;
-  writeFileSync16(join23(fnDir, "src/types.ts"), content);
+  writeFileSync17(join25(fnDir, "src/types.ts"), content);
 }
 
 // src/commands/generate/generators/structure.ts
@@ -4170,7 +4796,7 @@ async function generateFunctionStructure(options) {
     "src/client/store",
     "src/client/components"
   ];
-  dirs.forEach((dir) => mkdirSync5(join24(fnDir, dir), { recursive: true }));
+  dirs.forEach((dir) => mkdirSync5(join26(fnDir, dir), { recursive: true }));
   generatePackageJson(fnDir, scope, fnName, description);
   generateTsConfig(fnDir);
   generateTsupConfig(fnDir);
@@ -4190,15 +4816,15 @@ async function generateFunctionStructure(options) {
     generateEntitiesIndex(fnDir, entities);
     generateRepositoriesIndex(fnDir, entities);
   } else {
-    writeFileSync17(join24(fnDir, "src/server/entities/index.ts"), "// Export your entities here\nexport {}\n");
-    writeFileSync17(join24(fnDir, "src/server/repositories/index.ts"), "// Export your repositories here\nexport {}\n");
-  }
-  writeFileSync17(join24(fnDir, "src/client/hooks/index.ts"), "/**\n * Client Hooks\n */\n\n// TODO: Add hooks (e.g., useAuth, useData, etc.)\nexport {}\n");
-  writeFileSync17(join24(fnDir, "src/client/store/index.ts"), "/**\n * Client Store\n */\n\n// TODO: Add Zustand store if needed\nexport {}\n");
-  writeFileSync17(join24(fnDir, "src/client/components/index.ts"), "/**\n * Client Components\n */\n\n// TODO: Add React components\nexport {}\n");
-  writeFileSync17(join24(fnDir, "src/client/index.ts"), "/**\n * Client Module Entry\n */\n\nexport * from './hooks';\nexport * from './store';\nexport * from './components';\n");
-  writeFileSync17(join24(fnDir, "src/lib/types/index.ts"), "/**\n * Shared Type Definitions\n */\n\n// Add your shared types here\nexport {}\n");
-  writeFileSync17(join24(fnDir, "src/lib/contracts/index.ts"), "/**\n * API Contracts\n */\n\n// Export your contracts here\nexport {}\n");
+    writeFileSync18(join26(fnDir, "src/server/entities/index.ts"), "// Export your entities here\nexport {}\n");
+    writeFileSync18(join26(fnDir, "src/server/repositories/index.ts"), "// Export your repositories here\nexport {}\n");
+  }
+  writeFileSync18(join26(fnDir, "src/client/hooks/index.ts"), "/**\n * Client Hooks\n */\n\n// TODO: Add hooks (e.g., useAuth, useData, etc.)\nexport {}\n");
+  writeFileSync18(join26(fnDir, "src/client/store/index.ts"), "/**\n * Client Store\n */\n\n// TODO: Add Zustand store if needed\nexport {}\n");
+  writeFileSync18(join26(fnDir, "src/client/components/index.ts"), "/**\n * Client Components\n */\n\n// TODO: Add React components\nexport {}\n");
+  writeFileSync18(join26(fnDir, "src/client/index.ts"), "/**\n * Client Module Entry\n */\n\nexport * from './hooks';\nexport * from './store';\nexport * from './components';\n");
+  writeFileSync18(join26(fnDir, "src/lib/types/index.ts"), "/**\n * Shared Type Definitions\n */\n\n// Add your shared types here\nexport {}\n");
+  writeFileSync18(join26(fnDir, "src/lib/contracts/index.ts"), "/**\n * API Contracts\n */\n\n// Export your contracts here\nexport {}\n");
   generateMainIndex(fnDir, fnName);
   generateServerIndex(fnDir);
   generateClientIndex(fnDir);
@@ -4222,8 +4848,8 @@ async function generateFunction(name, options) {
     logger.error("Function name is required");
     process.exit(1);
   }
-  const fnDir = join25(cwd, fnName);
-  if (existsSync22(fnDir)) {
+  const fnDir = join27(cwd, fnName);
+  if (existsSync24(fnDir)) {
     logger.error(`Directory ${fnName} already exists at ${fnDir}`);
     process.exit(1);
   }
@@ -4268,13 +4894,13 @@ async function generateFunction(name, options) {
     });
     spinner.succeed("Function structure generated");
     console.log("");
-    logger.success(`\u2728 Package ${chalk25.cyan(`${scope}/${fnName}`)} created successfully!
+    logger.success(`\u2728 Package ${chalk27.cyan(`${scope}/${fnName}`)} created successfully!
 `);
-    logger.info(chalk25.bold("\u{1F4DA} Next steps:"));
-    console.log(`  ${chalk25.gray("1.")} cd ${fnName}`);
-    console.log(`  ${chalk25.gray("2.")} pnpm install ${chalk25.dim("(in monorepo root)")}`);
-    console.log(`  ${chalk25.gray("3.")} pnpm build`);
-    console.log(`  ${chalk25.gray("4.")} ${chalk25.dim("Use the package in your app")}`);
+    logger.info(chalk27.bold("\u{1F4DA} Next steps:"));
+    console.log(`  ${chalk27.gray("1.")} cd ${fnName}`);
+    console.log(`  ${chalk27.gray("2.")} pnpm install ${chalk27.dim("(in monorepo root)")}`);
+    console.log(`  ${chalk27.gray("3.")} pnpm build`);
+    console.log(`  ${chalk27.gray("4.")} ${chalk27.dim("Use the package in your app")}`);
     console.log("");
   } catch (error) {
     spinner.fail("Failed to generate function");
@@ -4287,14 +4913,30 @@ generateCommand.command("fn").description("Generate a new SPFN function module")
 
 // src/commands/env.ts
 import { Command as Command12 } from "commander";
-import chalk26 from "chalk";
-import { existsSync as existsSync23, readFileSync as readFileSync8, writeFileSync as writeFileSync18 } from "fs";
+import chalk28 from "chalk";
+import { existsSync as existsSync25, readFileSync as readFileSync9, writeFileSync as writeFileSync19 } from "fs";
 import { resolve } from "path";
 import { parse } from "dotenv";
-var ENV_FILES = {
+var VALID_ENVS = ["local", "development", "staging", "production", "test"];
+var BASE_ENV_FILES = {
   nextjs: [".env", ".env.local"],
   server: [".env.server", ".env.server.local"]
 };
+function getEnvFilesForEnvironment(nodeEnv) {
+  const files = [".env"];
+  if (nodeEnv) {
+    files.push(`.env.${nodeEnv}`);
+  }
+  if (nodeEnv !== "test") {
+    files.push(".env.local");
+  }
+  if (nodeEnv) {
+    files.push(`.env.${nodeEnv}.local`);
+  }
+  files.push(".env.server");
+  files.push(".env.server.local");
+  return files;
+}
 function getTargetFile(schema) {
   const isNextjs = schema.nextjs ?? schema.key?.startsWith("NEXT_PUBLIC_");
   if (isNextjs) {
@@ -4320,27 +4962,26 @@ async function loadEnvSchema(packageName) {
 }
 function formatType(type) {
   const typeColors = {
-    string: chalk26.green,
-    number: chalk26.blue,
-    boolean: chalk26.yellow,
-    url: chalk26.cyan,
-    enum: chalk26.magenta,
-    json: chalk26.red
+    string: chalk28.green,
+    number: chalk28.blue,
+    boolean: chalk28.yellow,
+    url: chalk28.cyan,
+    enum: chalk28.magenta,
+    json: chalk28.red
   };
-  const colorFn = typeColors[type] || chalk26.white;
-  return colorFn(type);
+  return (typeColors[type] || chalk28.white)(type);
 }
 function formatDefault(value, type) {
   if (value === void 0) {
-    return chalk26.dim("(none)");
+    return chalk28.dim("(none)");
   }
   if (type === "string" || type === "url") {
-    return chalk26.green(`"${value}"`);
+    return chalk28.green(`"${value}"`);
   }
   if (type === "boolean") {
-    return value ? chalk26.green("true") : chalk26.red("false");
+    return value ? chalk28.green("true") : chalk28.red("false");
   }
-  return chalk26.cyan(String(value));
+  return chalk28.cyan(String(value));
 }
 async function listEnvVars(options) {
   const packageName = options.package || "@spfn/core";
@@ -4354,28 +4995,28 @@ async function listEnvVars(options) {
         acc[target].push([key, schema]);
         return acc;
       }, {});
-      console.log(chalk26.blue.bold(`
+      console.log(chalk28.blue.bold(`
 \u{1F4CB} Environment Variables by File (${packageName})
 `));
       for (const [file, vars] of Object.entries(grouped)) {
-        console.log(chalk26.bold.magenta(`
+        console.log(chalk28.bold.magenta(`
 ${file}`));
-        console.log(chalk26.dim("\u2500".repeat(50)));
+        console.log(chalk28.dim("\u2500".repeat(50)));
         for (const [key, schema] of vars) {
           printEnvVar(key, schema);
         }
       }
     } else {
-      console.log(chalk26.blue.bold(`
+      console.log(chalk28.blue.bold(`
 \u{1F4CB} Environment Variables (${packageName})
 `));
       for (const [key, schema] of allVars) {
         printEnvVar(key, schema, true);
       }
     }
-    console.log(chalk26.dim("\n\u{1F4A1} Tip: Use `spfn env init` to generate .env template files\n"));
+    console.log(chalk28.dim("\n\u{1F4A1} Tip: Use `spfn env init` to generate .env template files\n"));
   } catch (error) {
-    console.error(chalk26.red(`
+    console.error(chalk28.red(`
 \u274C ${error instanceof Error ? error.message : "Unknown error"}
 `));
     process.exit(1);
@@ -4383,17 +5024,17 @@ ${file}`));
 }
 function printEnvVar(key, schema, showFile = false) {
   const typeStr = formatType(schema.type);
-  const requiredStr = schema.required || schema.default !== void 0 ? chalk26.red("[required]") : chalk26.dim("[optional]");
-  const sensitiveStr = schema.sensitive ? chalk26.yellow(" [sensitive]") : "";
-  const fileStr = showFile ? chalk26.dim(` \u2192 ${getTargetFile(schema)}`) : "";
-  console.log(`${chalk26.bold.cyan(key)} ${chalk26.dim("(")}${typeStr}${chalk26.dim(")")} ${requiredStr}${sensitiveStr}${fileStr}`);
-  console.log(`  ${chalk26.dim(schema.description)}`);
+  const requiredStr = schema.required || schema.default !== void 0 ? chalk28.red("[required]") : chalk28.dim("[optional]");
+  const sensitiveStr = schema.sensitive ? chalk28.yellow(" [sensitive]") : "";
+  const fileStr = showFile ? chalk28.dim(` \u2192 ${getTargetFile(schema)}`) : "";
+  console.log(`${chalk28.bold.cyan(key)} ${chalk28.dim("(")}${typeStr}${chalk28.dim(")")} ${requiredStr}${sensitiveStr}${fileStr}`);
+  console.log(`  ${chalk28.dim(schema.description)}`);
   if (schema.default !== void 0) {
-    console.log(`  ${chalk26.dim("Default:")} ${formatDefault(schema.default, schema.type)}`);
+    console.log(`  ${chalk28.dim("Default:")} ${formatDefault(schema.default, schema.type)}`);
   }
   if (schema.examples && schema.examples.length > 0) {
     const exampleStr = schema.examples.map((ex) => formatDefault(ex, schema.type)).join(", ");
-    console.log(`  ${chalk26.dim("Examples:")} ${exampleStr}`);
+    console.log(`  ${chalk28.dim("Examples:")} ${exampleStr}`);
   }
   console.log();
 }
@@ -4401,7 +5042,7 @@ async function showEnvStats(options) {
   const packageName = options.package || "@spfn/core";
   try {
     const envSchema = await loadEnvSchema(packageName);
-    console.log(chalk26.blue.bold(`
+    console.log(chalk28.blue.bold(`
 \u{1F4CA} Environment Variable Statistics (${packageName})
 `));
     const allVars = Object.entries(envSchema);
@@ -4423,24 +5064,24 @@ async function showEnvStats(options) {
       acc[file] = (acc[file] || 0) + 1;
       return acc;
     }, {});
-    console.log(`${chalk26.bold("Total variables:")} ${chalk26.cyan(allVars.length)}`);
-    console.log(`${chalk26.bold("Required:")} ${chalk26.red(required.length)}`);
-    console.log(`${chalk26.bold("Optional:")} ${chalk26.dim(optional.length)}`);
-    console.log(`${chalk26.bold("Sensitive:")} ${chalk26.yellow(sensitive.length)}`);
-    console.log(chalk26.bold("\nBy Target:"));
-    console.log(`  ${chalk26.blue("Next.js accessible:")} ${chalk26.cyan(nextjsVars.length)}`);
-    console.log(`  ${chalk26.magenta("SPFN server only:")} ${chalk26.cyan(serverOnlyVars.length)}`);
-    console.log(chalk26.bold("\nBy File:"));
+    console.log(`${chalk28.bold("Total variables:")} ${chalk28.cyan(allVars.length)}`);
+    console.log(`${chalk28.bold("Required:")} ${chalk28.red(required.length)}`);
+    console.log(`${chalk28.bold("Optional:")} ${chalk28.dim(optional.length)}`);
+    console.log(`${chalk28.bold("Sensitive:")} ${chalk28.yellow(sensitive.length)}`);
+    console.log(chalk28.bold("\nBy Target:"));
+    console.log(`  ${chalk28.blue("Next.js accessible:")} ${chalk28.cyan(nextjsVars.length)}`);
+    console.log(`  ${chalk28.magenta("SPFN server only:")} ${chalk28.cyan(serverOnlyVars.length)}`);
+    console.log(chalk28.bold("\nBy File:"));
     for (const [file, count] of Object.entries(fileCount)) {
-      console.log(`  ${chalk26.dim(file)}: ${chalk26.cyan(count)}`);
+      console.log(`  ${chalk28.dim(file)}: ${chalk28.cyan(count)}`);
     }
-    console.log(chalk26.bold("\nBy Type:"));
+    console.log(chalk28.bold("\nBy Type:"));
     for (const [type, count] of Object.entries(typeCount)) {
-      console.log(`  ${formatType(type)}: ${chalk26.cyan(count)}`);
+      console.log(`  ${formatType(type)}: ${chalk28.cyan(count)}`);
     }
     console.log();
   } catch (error) {
-    console.error(chalk26.red(`
+    console.error(chalk28.red(`
 \u274C ${error instanceof Error ? error.message : "Unknown error"}
 `));
     process.exit(1);
@@ -4460,26 +5101,26 @@ async function searchEnvVars(query, options) {
       }
     }
     if (results.length === 0) {
-      console.log(chalk26.yellow(`
+      console.log(chalk28.yellow(`
 \u26A0\uFE0F  No environment variables found matching "${query}"
 `));
       return;
     }
-    console.log(chalk26.blue.bold(`
+    console.log(chalk28.blue.bold(`
 \u{1F50D} Found ${results.length} environment variable(s) matching "${query}"
 `));
     for (const [key, schema] of results) {
       const typeStr = formatType(schema.type);
-      const requiredStr = schema.required || schema.default !== void 0 ? chalk26.red("[required]") : chalk26.dim("[optional]");
-      console.log(`${chalk26.bold.cyan(key)} ${chalk26.dim("(")}${typeStr}${chalk26.dim(")")} ${requiredStr}`);
-      console.log(`  ${chalk26.dim(schema.description)}`);
+      const requiredStr = schema.required || schema.default !== void 0 ? chalk28.red("[required]") : chalk28.dim("[optional]");
+      console.log(`${chalk28.bold.cyan(key)} ${chalk28.dim("(")}${typeStr}${chalk28.dim(")")} ${requiredStr}`);
+      console.log(`  ${chalk28.dim(schema.description)}`);
       if (schema.default !== void 0) {
-        console.log(`  ${chalk26.dim("Default:")} ${formatDefault(schema.default, schema.type)}`);
+        console.log(`  ${chalk28.dim("Default:")} ${formatDefault(schema.default, schema.type)}`);
       }
       console.log();
     }
   } catch (error) {
-    console.error(chalk26.red(`
+    console.error(chalk28.red(`
 \u274C ${error instanceof Error ? error.message : "Unknown error"}
 `));
     process.exit(1);
@@ -4489,8 +5130,19 @@ var envCommand = new Command12("env").description("Manage environment variables"
 envCommand.command("list").description("List all environment variables from schema").option("-p, --package <package>", "Package name to read env schema from", "@spfn/core").option("-g, --group", "Group variables by target file").action(listEnvVars);
 envCommand.command("stats").description("Show environment variable statistics").option("-p, --package <package>", "Package name to read env schema from", "@spfn/core").action(showEnvStats);
 envCommand.command("search").description("Search environment variables").argument("<query>", "Search query (matches key or description)").option("-p, --package <package>", "Package name to read env schema from", "@spfn/core").action(searchEnvVars);
+function validateEnvOption(envValue) {
+  if (!VALID_ENVS.includes(envValue)) {
+    console.error(chalk28.red(`
+\u274C Invalid environment: "${envValue}"`));
+    console.log(chalk28.dim(`   Valid values: ${VALID_ENVS.join(", ")}
+`));
+    process.exit(1);
+  }
+  return envValue;
+}
 async function initEnvFiles(options) {
   const packageName = options.package || "@spfn/core";
+  const targetEnv = options.env ? validateEnvOption(options.env) : void 0;
   const cwd = process.cwd();
   try {
     const envSchema = await loadEnvSchema(packageName);
@@ -4502,31 +5154,57 @@ async function initEnvFiles(options) {
       acc[exampleFile].push([key, schema]);
       return acc;
     }, {});
-    console.log(chalk26.blue.bold(`
+    if (targetEnv) {
+      console.log(chalk28.blue.bold(`
+\u{1F680} Generating .env template files for ${chalk28.cyan(targetEnv)} environment
+`));
+      const envSpecificFiles = {};
+      const committedVars = allVars.filter(([_, schema]) => !schema.sensitive);
+      if (committedVars.length > 0) {
+        envSpecificFiles[`.env.${targetEnv}.example`] = committedVars;
+      }
+      const sensitiveVars = allVars.filter(([_, schema]) => schema.sensitive);
+      if (sensitiveVars.length > 0) {
+        envSpecificFiles[`.env.${targetEnv}.local.example`] = sensitiveVars;
+      }
+      const allGrouped = { ...grouped, ...envSpecificFiles };
+      for (const [file, vars] of Object.entries(allGrouped)) {
+        writeEnvTemplate(cwd, file, vars, options.force ?? false);
+      }
+    } else {
+      console.log(chalk28.blue.bold(`
 \u{1F680} Generating .env template files
 `));
-    for (const [file, vars] of Object.entries(grouped)) {
-      const filePath = resolve(cwd, file);
-      if (existsSync23(filePath) && !options.force) {
-        console.log(chalk26.yellow(`  \u23ED\uFE0F  ${file} already exists (use --force to overwrite)`));
-        continue;
+      for (const [file, vars] of Object.entries(grouped)) {
+        writeEnvTemplate(cwd, file, vars, options.force ?? false);
       }
-      const content = generateEnvFileContent(vars);
-      writeFileSync18(filePath, content, "utf-8");
-      console.log(chalk26.green(`  \u2705 ${file} (${vars.length} variables)`));
-    }
-    console.log(chalk26.dim("\n\u{1F4A1} Copy .example files to create your actual .env files:"));
-    console.log(chalk26.dim("   cp .env.example .env"));
-    console.log(chalk26.dim("   cp .env.local.example .env.local"));
-    console.log(chalk26.dim("   cp .env.server.example .env.server"));
-    console.log(chalk26.dim("   cp .env.server.local.example .env.server.local\n"));
+    }
+    console.log(chalk28.dim("\n\u{1F4A1} Copy .example files to create your actual .env files:"));
+    console.log(chalk28.dim("   cp .env.example .env"));
+    console.log(chalk28.dim("   cp .env.local.example .env.local"));
+    console.log(chalk28.dim("   cp .env.server.example .env.server"));
+    console.log(chalk28.dim("   cp .env.server.local.example .env.server.local"));
+    if (targetEnv) {
+      console.log(chalk28.dim(`   cp .env.${targetEnv}.example .env.${targetEnv}`));
+      console.log(chalk28.dim(`   cp .env.${targetEnv}.local.example .env.${targetEnv}.local`));
+    }
+    console.log("");
   } catch (error) {
-    console.error(chalk26.red(`
+    console.error(chalk28.red(`
 \u274C ${error instanceof Error ? error.message : "Unknown error"}
 `));
     process.exit(1);
   }
 }
+function writeEnvTemplate(cwd, file, vars, force) {
+  const filePath = resolve(cwd, file);
+  if (existsSync25(filePath) && !force) {
+    console.log(chalk28.yellow(`  \u23ED\uFE0F  ${file} already exists (use --force to overwrite)`));
+    return;
+  }
+  writeFileSync19(filePath, generateEnvFileContent(vars), "utf-8");
+  console.log(chalk28.green(`  \u2705 ${file} (${vars.length} variables)`));
+}
 function generateEnvFileContent(vars) {
   const lines = [
     "# Auto-generated by spfn env init",
@@ -4554,28 +5232,30 @@ function generateEnvFileContent(vars) {
 }
 async function checkEnvFiles(options) {
   const packageName = options.package || "@spfn/core";
+  const targetEnv = options.env ? validateEnvOption(options.env) : void 0;
   const cwd = process.cwd();
   try {
     const envSchema = await loadEnvSchema(packageName);
     const allVars = Object.entries(envSchema);
-    console.log(chalk26.blue.bold(`
-\u{1F50D} Checking .env files against schema
+    const envLabel = targetEnv ? ` (${targetEnv})` : "";
+    console.log(chalk28.blue.bold(`
+\u{1F50D} Checking .env files against schema${envLabel}
 `));
-    const allFiles = [...ENV_FILES.nextjs, ...ENV_FILES.server];
+    const filesToCheck = targetEnv ? getEnvFilesForEnvironment(targetEnv) : [...BASE_ENV_FILES.nextjs, ...BASE_ENV_FILES.server];
     const loadedEnv = {};
     const issues = [];
     const warnings = [];
-    for (const file of allFiles) {
+    for (const file of filesToCheck) {
       const filePath = resolve(cwd, file);
-      if (!existsSync23(filePath)) {
+      if (!existsSync25(filePath)) {
         continue;
       }
-      const content = readFileSync8(filePath, "utf-8");
+      const content = readFileSync9(filePath, "utf-8");
       const parsed = parse(content);
       for (const [key, value] of Object.entries(parsed)) {
         loadedEnv[key] = { value: value || "", file };
       }
-      console.log(chalk26.dim(`  \u{1F4C4} ${file} loaded`));
+      console.log(chalk28.dim(`  \u{1F4C4} ${file} loaded`));
     }
     console.log("");
     for (const [key, schema] of allVars) {
@@ -4583,21 +5263,21 @@ async function checkEnvFiles(options) {
       const found = loadedEnv[key];
       if (!found) {
         if (schema.required && schema.default === void 0) {
-          issues.push(`${chalk26.red("\u2717")} ${chalk26.cyan(key)} is required but not found in any .env file`);
+          issues.push(`${chalk28.red("\u2717")} ${chalk28.cyan(key)} is required but not found in any .env file`);
         }
         continue;
       }
-      const isNextjsFile = ENV_FILES.nextjs.includes(found.file);
-      const isServerFile = ENV_FILES.server.includes(found.file);
+      const isNextjsFile = BASE_ENV_FILES.nextjs.includes(found.file);
+      const isServerFile = BASE_ENV_FILES.server.includes(found.file);
       const shouldBeNextjs = schema.nextjs ?? key.startsWith("NEXT_PUBLIC_");
       if (!shouldBeNextjs && isNextjsFile && !isServerFile) {
         if (schema.sensitive) {
           issues.push(
-            `${chalk26.red("\u2717")} ${chalk26.cyan(key)} is sensitive and should be in ${chalk26.magenta(expectedFile)}, but found in ${chalk26.yellow(found.file)} (security risk!)`
+            `${chalk28.red("\u2717")} ${chalk28.cyan(key)} is sensitive and should be in ${chalk28.magenta(expectedFile)}, but found in ${chalk28.yellow(found.file)} (security risk!)`
           );
         } else {
           warnings.push(
-            `${chalk26.yellow("\u26A0")} ${chalk26.cyan(key)} should be in ${chalk26.magenta(expectedFile)}, but found in ${chalk26.dim(found.file)}`
+            `${chalk28.yellow("\u26A0")} ${chalk28.cyan(key)} should be in ${chalk28.magenta(expectedFile)}, but found in ${chalk28.dim(found.file)}`
           );
         }
       }
@@ -4605,51 +5285,64 @@ async function checkEnvFiles(options) {
     for (const [key, { file }] of Object.entries(loadedEnv)) {
       const inSchema = allVars.some(([k]) => k === key);
       if (!inSchema) {
-        warnings.push(`${chalk26.yellow("\u26A0")} ${chalk26.cyan(key)} in ${chalk26.dim(file)} is not in schema`);
+        warnings.push(`${chalk28.yellow("\u26A0")} ${chalk28.cyan(key)} in ${chalk28.dim(file)} is not in schema`);
       }
     }
     if (issues.length > 0) {
-      console.log(chalk26.red.bold("Issues:"));
+      console.log(chalk28.red.bold("Issues:"));
       for (const issue of issues) {
         console.log(`  ${issue}`);
       }
       console.log("");
     }
     if (warnings.length > 0) {
-      console.log(chalk26.yellow.bold("Warnings:"));
+      console.log(chalk28.yellow.bold("Warnings:"));
       for (const warning of warnings) {
         console.log(`  ${warning}`);
       }
       console.log("");
     }
     if (issues.length === 0 && warnings.length === 0) {
-      console.log(chalk26.green("\u2705 All environment variables are correctly configured!\n"));
+      console.log(chalk28.green("\u2705 All environment variables are correctly configured!\n"));
     } else {
-      console.log(chalk26.dim(`Found ${issues.length} issue(s) and ${warnings.length} warning(s)
+      console.log(chalk28.dim(`Found ${issues.length} issue(s) and ${warnings.length} warning(s)
 `));
       if (issues.length > 0) {
         process.exit(1);
       }
     }
   } catch (error) {
-    console.error(chalk26.red(`
+    console.error(chalk28.red(`
 \u274C ${error instanceof Error ? error.message : "Unknown error"}
 `));
     process.exit(1);
   }
 }
-envCommand.command("init").description("Generate .env template files from schema").option("-p, --package <package>", "Package name to read env schema from", "@spfn/core").option("-f, --force", "Overwrite existing files").action(initEnvFiles);
-envCommand.command("check").description("Check .env files against schema").option("-p, --package <package>", "Package name to read env schema from", "@spfn/core").action(checkEnvFiles);
+envCommand.command("init").description("Generate .env template files from schema").option("-p, --package <package>", "Package name to read env schema from", "@spfn/core").option("-e, --env <environment>", "Generate environment-specific templates (e.g. production, staging)").option("-f, --force", "Overwrite existing files").action(initEnvFiles);
+envCommand.command("check").description("Check .env files against schema").option("-p, --package <package>", "Package name to read env schema from", "@spfn/core").option("-e, --env <environment>", "Check files for a specific environment (e.g. production)").action(checkEnvFiles);
 async function validateEnvVars(options) {
   const packages = options.packages || ["@spfn/core"];
-  console.log(chalk26.blue.bold(`
+  const targetEnv = options.env ? validateEnvOption(options.env) : void 0;
+  if (targetEnv) {
+    const { loadEnv: loadEnv8 } = await import("@spfn/core/env/loader");
+    const result = loadEnv8({ nodeEnv: targetEnv });
+    console.log(chalk28.blue.bold(`
+\u{1F50D} Validating environment variables for ${chalk28.cyan(targetEnv)}
+`));
+    if (result.loadedFiles.length > 0) {
+      console.log(chalk28.dim(`  Loaded: ${result.loadedFiles.join(", ")}`));
+    }
+    console.log("");
+  } else {
+    console.log(chalk28.blue.bold(`
 \u{1F50D} Validating environment variables
 `));
+  }
   const allErrors = [];
   const allWarnings = [];
   for (const packageName of packages) {
     try {
-      console.log(chalk26.dim(`  \u{1F4E6} ${packageName}`));
+      console.log(chalk28.dim(`  \u{1F4E6} ${packageName}`));
       const envSchema = await loadEnvSchema(packageName);
       const { createEnvRegistry } = await import("@spfn/core/env");
       const registry = createEnvRegistry(envSchema);
@@ -4662,10 +5355,10 @@ async function validateEnvVars(options) {
       }
     } catch (error) {
       if (error instanceof Error && error.message.includes("does not export envSchema")) {
-        console.log(chalk26.dim(`    \u23ED\uFE0F  No envSchema exported, skipping`));
+        console.log(chalk28.dim(`    \u23ED\uFE0F  No envSchema exported, skipping`));
         continue;
       }
-      console.error(chalk26.red(`    \u274C Failed to load: ${error instanceof Error ? error.message : String(error)}`));
+      console.error(chalk28.red(`    \u274C Failed to load: ${error instanceof Error ? error.message : String(error)}`));
       if (options.strict) {
         process.exit(1);
       }
@@ -4673,42 +5366,43 @@ async function validateEnvVars(options) {
   }
   console.log("");
   if (allErrors.length > 0) {
-    console.log(chalk26.red.bold(`\u274C Validation Errors (${allErrors.length}):
+    console.log(chalk28.red.bold(`\u274C Validation Errors (${allErrors.length}):
 `));
     for (const error of allErrors) {
-      console.log(`  ${chalk26.red("\u2717")} ${chalk26.cyan(error.key)}`);
-      console.log(`    ${chalk26.dim(error.message)}`);
-      console.log(`    ${chalk26.dim(`from ${error.package}`)}`);
+      console.log(`  ${chalk28.red("\u2717")} ${chalk28.cyan(error.key)}`);
+      console.log(`    ${chalk28.dim(error.message)}`);
+      console.log(`    ${chalk28.dim(`from ${error.package}`)}`);
       console.log("");
     }
   }
   if (allWarnings.length > 0) {
-    console.log(chalk26.yellow.bold(`\u26A0\uFE0F  Warnings (${allWarnings.length}):
+    console.log(chalk28.yellow.bold(`\u26A0\uFE0F  Warnings (${allWarnings.length}):
 `));
     for (const warning of allWarnings) {
-      console.log(`  ${chalk26.yellow("\u26A0")} ${chalk26.cyan(warning.key)}`);
-      console.log(`    ${chalk26.dim(warning.message)}`);
+      console.log(`  ${chalk28.yellow("\u26A0")} ${chalk28.cyan(warning.key)}`);
+      console.log(`    ${chalk28.dim(warning.message)}`);
       console.log("");
     }
   }
   if (allErrors.length === 0 && allWarnings.length === 0) {
-    console.log(chalk26.green.bold("\u2705 All environment variables are valid!\n"));
+    console.log(chalk28.green.bold("\u2705 All environment variables are valid!\n"));
   } else if (allErrors.length === 0) {
-    console.log(chalk26.green("\u2705 No errors found."));
-    console.log(chalk26.yellow(`\u26A0\uFE0F  ${allWarnings.length} warning(s) found.
+    console.log(chalk28.green("\u2705 No errors found."));
+    console.log(chalk28.yellow(`\u26A0\uFE0F  ${allWarnings.length} warning(s) found.
 `));
   } else {
-    console.log(chalk26.red(`
+    console.log(chalk28.red(`
 \u274C Validation failed with ${allErrors.length} error(s)
 `));
     process.exit(1);
   }
 }
-envCommand.command("validate").description("Validate environment variables against schema (for CI/CD)").option("-p, --packages <packages...>", "Packages to validate", ["@spfn/core"]).option("-s, --strict", "Exit on any error (including load failures)").action(validateEnvVars);
+envCommand.command("validate").description("Validate environment variables against schema (for CI/CD)").option("-p, --packages <packages...>", "Packages to validate", ["@spfn/core"]).option("-e, --env <environment>", "Load env files for specific environment before validating").option("-s, --strict", "Exit on any error (including load failures)").action(validateEnvVars);
 
 // src/index.ts
+init_version();
 var program = new Command13();
-program.name("spfn").description("SPFN CLI - The Missing Backend for Next.js").version("0.1.0");
+program.name("spfn").description("SPFN CLI - The Missing Backend for Next.js").version(getCliVersion());
 program.addCommand(createCommand);
 program.addCommand(initCommand);
 program.addCommand(addCommand);