prisma-flow 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command14 } from "commander";
+import { createRequire as createRequire2 } from "module";
+import { Command as Command15 } from "commander";
 
 // src/commands/check.ts
 import chalk from "chalk";
@@ -22,10 +23,10 @@ function makeConsoleLogger(level) {
     error: 50
   };
   const activeLevel = levels[level] ?? 30;
-  function write(severity, lvl, args) {
+  function write(severity, lvl, args2) {
     if (lvl < activeLevel) return;
-    const obj = typeof args[0] === "object" && args[0] !== null ? args[0] : {};
-    const msg = typeof args[0] === "string" ? args[0] : args[1] ?? "";
+    const obj = typeof args2[0] === "object" && args2[0] !== null ? args2[0] : {};
+    const msg = typeof args2[0] === "string" ? args2[0] : args2[1] ?? "";
     const line = JSON.stringify({
       time: (/* @__PURE__ */ new Date()).toISOString(),
       level: severity,
@@ -115,71 +116,22 @@ async function writeAuditEntry(cwd, action, result, detail, maxMb = DEFAULT_MAX_
 // src/core/migration-analyzer.ts
 import fs4 from "fs/promises";
 
-// src/core/prisma-cli.ts
-import { execFile } from "child_process";
+// src/core/prisma-detector.ts
 import fs2 from "fs/promises";
 import path2 from "path";
-import { promisify } from "util";
-var execFileAsync = promisify(execFile);
-async function fileExists(filePath) {
-  try {
-    await fs2.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function resolveLocalPrismaCli(cwd) {
-  let current = path2.resolve(cwd);
-  while (true) {
-    const candidate = path2.join(current, "node_modules", "prisma", "build", "index.js");
-    if (await fileExists(candidate)) return candidate;
-    const parent = path2.dirname(current);
-    if (parent === current) return null;
-    current = parent;
-  }
-}
-async function resolveBundledNpxCli() {
-  const candidate = path2.join(
-    path2.dirname(process.execPath),
-    "node_modules",
-    "npm",
-    "bin",
-    "npx-cli.js"
-  );
-  return await fileExists(candidate) ? candidate : null;
+import dotenv from "dotenv";
+function resolveSqliteFilePath(databaseUrl, schemaPath) {
+  if (!databaseUrl.startsWith("file:")) return null;
+  const rawPath = databaseUrl.slice("file:".length);
+  if (!rawPath || rawPath === ":memory:") return rawPath;
+  if (path2.isAbsolute(rawPath)) return rawPath;
+  const schemaDir = path2.dirname(schemaPath);
+  return path2.resolve(schemaDir, rawPath);
 }
-async function execPrisma(cwd, args, options = {}) {
-  const localCli = await resolveLocalPrismaCli(cwd);
-  if (localCli) {
-    return execFileAsync(process.execPath, [localCli, ...args], {
-      cwd,
-      env: options.env,
-      timeout: options.timeout
-    });
-  }
-  if (process.platform === "win32") {
-    const npxCli = await resolveBundledNpxCli();
-    if (npxCli) {
-      return execFileAsync(process.execPath, [npxCli, "prisma", ...args], {
-        cwd,
-        env: options.env,
-        timeout: options.timeout
-      });
-    }
-  }
-  const command = process.platform === "win32" ? "npx.cmd" : "npx";
-  return execFileAsync(command, ["prisma", ...args], {
-    cwd,
-    env: options.env,
-    timeout: options.timeout
-  });
+function normalizeDatabaseUrlForPrismaCommand(databaseUrl, schemaPath) {
+  const sqlitePath = resolveSqliteFilePath(databaseUrl, schemaPath);
+  return sqlitePath ? `file:${sqlitePath}` : databaseUrl;
 }
-
-// src/core/prisma-detector.ts
-import fs3 from "fs/promises";
-import path3 from "path";
-import dotenv from "dotenv";
 function detectProviderFromSchema(schemaContent) {
   const match = schemaContent.match(/datasource\s+\w+\s*\{[^}]*provider\s*=\s*"([^"]+)"/s);
   if (!match) return null;
@@ -196,20 +148,20 @@ function detectProviderFromSchema(schemaContent) {
 }
 async function tryAccess(p) {
   try {
-    await fs3.access(p);
+    await fs2.access(p);
     return true;
   } catch {
     return false;
   }
 }
 async function findSchemaPath(cwd) {
-  const candidates = [path3.join(cwd, "prisma", "schema.prisma"), path3.join(cwd, "schema.prisma")];
+  const candidates = [path2.join(cwd, "prisma", "schema.prisma"), path2.join(cwd, "schema.prisma")];
   for (const p of candidates) {
     if (await tryAccess(p)) return p;
   }
-  const schemaDir = path3.join(cwd, "prisma", "schema");
+  const schemaDir = path2.join(cwd, "prisma", "schema");
   if (await tryAccess(schemaDir)) {
-    const entries = await fs3.readdir(schemaDir).catch(() => []);
+    const entries = await fs2.readdir(schemaDir).catch(() => []);
     const prismaFiles = entries.filter((e) => e.endsWith(".prisma"));
     if (prismaFiles.length > 0) {
       return schemaDir;
@@ -219,15 +171,15 @@ async function findSchemaPath(cwd) {
 }
 async function readSchemaContent(schemaPath) {
   try {
-    const stat = await fs3.stat(schemaPath);
+    const stat = await fs2.stat(schemaPath);
     if (stat.isDirectory()) {
-      const files = (await fs3.readdir(schemaPath)).filter((f) => f.endsWith(".prisma")).sort();
+      const files = (await fs2.readdir(schemaPath)).filter((f) => f.endsWith(".prisma")).sort();
       const parts = await Promise.all(
-        files.map((f) => fs3.readFile(path3.join(schemaPath, f), "utf-8"))
+        files.map((f) => fs2.readFile(path2.join(schemaPath, f), "utf-8"))
       );
       return parts.join("\n");
     }
-    return fs3.readFile(schemaPath, "utf-8");
+    return fs2.readFile(schemaPath, "utf-8");
   } catch {
     return "";
   }
@@ -240,13 +192,13 @@ async function detectPackageManager(cwd) {
     { file: "bun.lockb", manager: "bun" }
   ];
   for (const { file, manager } of lockfiles) {
-    if (await tryAccess(path3.join(cwd, file))) return manager;
+    if (await tryAccess(path2.join(cwd, file))) return manager;
   }
   return null;
 }
 async function detectPrismaVersion(cwd) {
   try {
-    const content = await fs3.readFile(path3.join(cwd, "package.json"), "utf-8");
+    const content = await fs2.readFile(path2.join(cwd, "package.json"), "utf-8");
     const pkg = JSON.parse(content);
     return pkg.dependencies?.prisma ?? pkg.devDependencies?.prisma ?? null;
   } catch {
@@ -258,9 +210,9 @@ async function detectPrismaProject(cwd) {
   if (!schemaPath) return null;
   const schemaContent = await readSchemaContent(schemaPath);
   let databaseUrl = "";
-  for (const envFile of [path3.join(cwd, ".env"), path3.join(cwd, "prisma", ".env")]) {
+  for (const envFile of [path2.join(cwd, ".env"), path2.join(cwd, "prisma", ".env")]) {
     try {
-      const envContent = await fs3.readFile(envFile, "utf-8");
+      const envContent = await fs2.readFile(envFile, "utf-8");
       const parsed = dotenv.parse(envContent);
       if (parsed.DATABASE_URL) {
         databaseUrl = parsed.DATABASE_URL;
@@ -269,15 +221,15 @@ async function detectPrismaProject(cwd) {
     } catch {
     }
   }
-  const schemaDir = await fs3.stat(schemaPath).then((s) => s.isDirectory()).catch(() => false) ? schemaPath : path3.dirname(schemaPath);
-  const migrationsPath = path3.join(schemaDir, "migrations");
+  const schemaDir = await fs2.stat(schemaPath).then((s) => s.isDirectory()).catch(() => false) ? schemaPath : path2.dirname(schemaPath);
+  const migrationsPath = path2.join(schemaDir, "migrations");
   const migrations = [];
   try {
-    const entries = await fs3.readdir(migrationsPath, { withFileTypes: true });
+    const entries = await fs2.readdir(migrationsPath, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name === "migration_lock.toml") continue;
-      const migrationDir = path3.join(migrationsPath, entry.name);
-      const sqlPath = path3.join(migrationDir, "migration.sql");
+      const migrationDir = path2.join(migrationsPath, entry.name);
+      const sqlPath = path2.join(migrationDir, "migration.sql");
       if (!await tryAccess(sqlPath)) continue;
       const timestampStr = entry.name.slice(0, 14);
       const year = Number.parseInt(timestampStr.slice(0, 4), 10);
@@ -321,27 +273,14 @@ function classifyDriftSql(sql) {
   const upper = sql.toUpperCase().trimStart();
   if (upper.startsWith("CREATE TABLE")) return "table-missing";
   if (upper.startsWith("DROP TABLE")) return "table-extra";
-  if (upper.startsWith("CREATE INDEX") || upper.startsWith("DROP INDEX")) return "index-change";
+  if (upper.startsWith("CREATE INDEX") || upper.startsWith("CREATE UNIQUE INDEX") || upper.startsWith("DROP INDEX")) {
+    return "index-change";
+  }
   if (upper.startsWith("ALTER INDEX")) return "index-change";
   if (upper.includes("CONSTRAINT")) return "constraint-change";
   if (upper.startsWith("ALTER TABLE")) return "column-mismatch";
   return "unknown";
 }
-function labelDriftType(type) {
-  const labels = {
-    "table-missing": "Table missing in database",
-    "table-extra": "Table exists in database but not in schema",
-    "column-mismatch": "Column or table structure mismatch",
-    "index-change": "Index difference detected",
-    "constraint-change": "Constraint difference detected",
-    unknown: "Unknown schema change",
-    missing_migration: "Migration applied to DB but missing from history",
-    extra_column: "Extra column present in DB not in schema",
-    extra_table: "Extra table present in DB not in schema",
-    modified_migration: "Migration SQL was modified after being applied"
-  };
-  return labels[type];
-}
 function parseSqlStatements(sql) {
   const statements = [];
   let current = "";
@@ -398,42 +337,620 @@ async function detectDrift(cwd) {
       errorMessage: "No Prisma project found"
     };
   }
+  const adapter = getPrismaAdapter(project.prismaVersion);
+  return adapter.detectDrift(cwd, project.schemaPath, project.databaseUrl, project.provider);
+}
+
+// src/core/prisma-cli.ts
+import { execFile } from "child_process";
+import fs3 from "fs/promises";
+import path3 from "path";
+async function fileExists(filePath) {
+  try {
+    await fs3.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveLocalPrismaCli(cwd) {
+  let current = path3.resolve(cwd);
+  while (true) {
+    const candidate = path3.join(current, "node_modules", "prisma", "build", "index.js");
+    if (await fileExists(candidate)) return candidate;
+    const parent = path3.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+async function resolveBundledNpxCli() {
+  const candidate = path3.join(
+    path3.dirname(process.execPath),
+    "node_modules",
+    "npm",
+    "bin",
+    "npx-cli.js"
+  );
+  return await fileExists(candidate) ? candidate : null;
+}
+function killProcessTree(pid) {
+  if (process.platform === "win32") {
+    const child = execFile("taskkill.exe", ["/pid", String(pid), "/T", "/F"]);
+    child.on("error", () => {
+    });
+    return;
+  }
   try {
-    const { stdout } = await execPrisma(
+    process.kill(pid, "SIGTERM");
+  } catch {
+  }
+}
+function execFileWithTimeout(command, args2, options) {
+  return new Promise((resolve, reject) => {
+    const child = execFile(command, args2, {
+      cwd: options.cwd,
+      env: options.env,
+      windowsHide: true,
+      maxBuffer: 10 * 1024 * 1024
+    });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    child.stdout?.setEncoding("utf-8");
+    child.stderr?.setEncoding("utf-8");
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    const timer = options.timeout && options.timeout > 0 ? setTimeout(() => {
+      timedOut = true;
+      if (child.pid) killProcessTree(child.pid);
+    }, options.timeout) : null;
+    child.on("error", (error) => {
+      if (timer) clearTimeout(timer);
+      reject(error);
+    });
+    child.on("close", (code, signal) => {
+      if (timer) clearTimeout(timer);
+      if (timedOut) {
+        const timeoutError = new Error(
+          `Prisma CLI timed out after ${options.timeout}ms: ${command} ${args2.join(" ")}`
+        );
+        timeoutError.code = "ETIMEDOUT";
+        timeoutError.stdout = stdout;
+        timeoutError.stderr = stderr;
+        timeoutError.signal = signal;
+        reject(timeoutError);
+        return;
+      }
+      if (code && code !== 0) {
+        const commandError = new Error(
+          stderr.trim() || `Prisma CLI exited with code ${code}`
+        );
+        commandError.code = code;
+        commandError.stdout = stdout;
+        commandError.stderr = stderr;
+        reject(commandError);
+        return;
+      }
+      resolve({ stdout, stderr });
+    });
+  });
+}
+async function execPrisma(cwd, args2, options = {}) {
+  const localCli = await resolveLocalPrismaCli(cwd);
+  if (localCli) {
+    return execFileWithTimeout(process.execPath, [localCli, ...args2], {
+      cwd,
+      env: options.env,
+      timeout: options.timeout
+    });
+  }
+  if (process.platform === "win32") {
+    const npxCli = await resolveBundledNpxCli();
+    if (npxCli) {
+      return execFileWithTimeout(process.execPath, [npxCli, "prisma", ...args2], {
+        cwd,
+        env: options.env,
+        timeout: options.timeout
+      });
+    }
+  }
+  const command = process.platform === "win32" ? "npx.cmd" : "npx";
+  return execFileWithTimeout(command, ["prisma", ...args2], {
+    cwd,
+    env: options.env,
+    timeout: options.timeout
+  });
+}
+function hasUnsupportedMigrateDiffFlag(error) {
+  if (!(error instanceof Error)) return false;
+  const commandError = error;
+  const message = `${error.message}
+${commandError.stderr ?? ""}`.toLowerCase();
+  return message.includes("was removed") || message.includes("unknown option") || message.includes("unexpected option");
+}
+async function execPrismaMigrateDiff(cwd, { fromSchema, legacyDestinationArgs, env, timeout }) {
+  const options = {
+    ...env === void 0 ? {} : { env },
+    ...timeout === void 0 ? {} : { timeout }
+  };
+  try {
+    return await execPrisma(
+      cwd,
+      ["migrate", "diff", "--from-schema", fromSchema, "--to-config-datasource", "--script"],
+      options
+    );
+  } catch (error) {
+    if (!hasUnsupportedMigrateDiffFlag(error)) throw error;
+    return execPrisma(
       cwd,
       [
         "migrate",
         "diff",
         "--from-schema-datamodel",
-        project.schemaPath,
-        "--to-schema-datasource",
-        project.schemaPath,
+        fromSchema,
+        ...legacyDestinationArgs,
         "--script"
       ],
-      { timeout: 3e4 }
+      options
     );
-    const output = stdout.trim();
-    if (!output) return { items: [], status: "clean" };
-    const items = parseSqlStatements(output).filter((s) => !s.toUpperCase().trimStart().startsWith("--")).map((sql) => {
-      const type = classifyDriftSql(sql);
-      return { sql, type, description: labelDriftType(type) };
-    });
-    return { items, status: items.length > 0 ? "drifted" : "clean" };
+  }
+}
+
+// src/core/adapters/base-adapter.ts
+function labelDriftType(type) {
+  const labels = {
+    "table-missing": "Table missing in database",
+    "table-extra": "Table exists in database but not in schema",
+    "column-mismatch": "Column or table structure mismatch",
+    "index-change": "Index difference detected",
+    "constraint-change": "Constraint difference detected",
+    unknown: "Unknown schema change",
+    missing_migration: "Migration applied to DB but missing from history",
+    extra_column: "Extra column present in DB not in schema",
+    extra_table: "Extra table present in DB not in schema",
+    modified_migration: "Migration SQL was modified after being applied"
+  };
+  return labels[type];
+}
+function parseStatusOutput(stdout, stderr, options) {
+  const statusMap = /* @__PURE__ */ new Map();
+  const combined = `${stdout}
+${stderr}`;
+  const isExitZero = options?.isExitZero ?? false;
+  if (combined.includes("P1001") || combined.includes("Can't reach database server") || combined.includes("Connection refused") || combined.includes("ECONNREFUSED") || combined.includes("ENOTFOUND")) {
+    return {
+      verification: "error",
+      connected: false,
+      statusMap,
+      errorCode: "DATABASE_UNREACHABLE",
+      errorMessage: "Database server is unreachable. Check DATABASE_URL."
+    };
+  }
+  if (combined.includes("P1000") || combined.includes("Authentication failed") || combined.includes("password authentication failed")) {
+    return {
+      verification: "error",
+      connected: false,
+      statusMap,
+      errorCode: "AUTHENTICATION_FAILED",
+      errorMessage: "Database credentials failed authentication."
+    };
+  }
+  if (combined.includes("P1012") || combined.includes("Schema validation error") || combined.includes("Error validating")) {
+    return {
+      verification: "error",
+      connected: false,
+      statusMap,
+      errorCode: "MALFORMED_SCHEMA",
+      errorMessage: "Prisma schema validation failed. Check schema syntax."
+    };
+  }
+  if (combined.includes("P1013") || combined.includes("Invalid configuration") || combined.includes("Invalid database string")) {
+    return {
+      verification: "error",
+      connected: false,
+      statusMap,
+      errorCode: "INVALID_CONFIG",
+      errorMessage: "Invalid Prisma configuration or database URL."
+    };
+  }
+  if (combined.includes("P3005") || combined.includes("not in sync with the migration history") || combined.includes("recorded in the database but missing locally")) {
+    return {
+      verification: "unknown",
+      connected: true,
+      statusMap,
+      errorCode: "MIGRATION_HISTORY_CONFLICT",
+      errorMessage: "Database schema is not in sync with local migration history."
+    };
+  }
+  const trimmedStderr = stderr.trim();
+  if (!isExitZero && trimmedStderr.length > 0) {
+    if (trimmedStderr.toLowerCase().includes("error") || trimmedStderr.toLowerCase().includes("failure") || trimmedStderr.toLowerCase().includes("fault") || trimmedStderr.toLowerCase().includes("panic") || trimmedStderr.toLowerCase().includes("unknown")) {
+      return {
+        verification: "unknown",
+        connected: false,
+        statusMap,
+        errorCode: "UNEXPECTED_CLI_FAILURE",
+        errorMessage: trimmedStderr
+      };
+    }
+  }
+  const lines = stdout.split("\n");
+  let mode = "none";
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (line.includes("have not yet been applied")) {
+      mode = "pending";
+      continue;
+    }
+    if (line.match(/failed to apply|rolled back|migration.*failed/i)) {
+      mode = "failed";
+      continue;
+    }
+    if (line.includes("Database schema is up to date") || line.includes("No pending migrations")) {
+      if (!isExitZero && trimmedStderr.length > 0) {
+        return {
+          verification: "unknown",
+          connected: false,
+          statusMap,
+          errorCode: "UNEXPECTED_CLI_FAILURE",
+          errorMessage: trimmedStderr || "Prisma CLI exited non-zero with clean stdout."
+        };
+      }
+      mode = "none";
+      continue;
+    }
+    if (line === "" || line.startsWith("\u2500") || line.startsWith("The following")) {
+      mode = "none";
+      continue;
+    }
+    if (mode === "none") continue;
+    const cleaned = line.replace(/^[•\-*]\s*/, "").trim();
+    if (cleaned.match(/^\d{14}/)) {
+      statusMap.set(cleaned, mode === "pending" ? "pending" : "failed");
+    }
+  }
+  if (statusMap.size > 0) {
+    return {
+      verification: "verified",
+      connected: true,
+      statusMap
+    };
+  }
+  if (isExitZero) {
+    return {
+      verification: "verified",
+      connected: true,
+      statusMap
+    };
+  }
+  return {
+    verification: "unknown",
+    connected: false,
+    statusMap,
+    errorCode: "UNEXPECTED_CLI_FAILURE",
+    errorMessage: trimmedStderr || stdout.trim() || "Prisma CLI exited unexpectedly with unknown status."
+  };
+}
+async function runPrismaMigrateStatus(cwd, schemaPath) {
+  try {
+    const { stdout, stderr } = await execPrisma(
+      cwd,
+      ["migrate", "status", "--schema", schemaPath],
+      {
+        timeout: 3e4
+      }
+    );
+    return parseStatusOutput(stdout, stderr, { isExitZero: true });
   } catch (err) {
     const error = err;
+    const stdout = error.stdout ?? "";
     const stderr = error.stderr ?? "";
-    if (stderr.includes("P1001") || stderr.includes("Can't reach database server") || stderr.includes("Connection refused")) {
-      logger.debug("Drift detection skipped: database unreachable");
-      return {
-        items: [],
-        status: "error",
-        errorMessage: "Database unreachable"
-      };
+    logger.debug({ stdout, stderr }, "prisma migrate status returned non-zero");
+    return parseStatusOutput(stdout, stderr, { isExitZero: false });
+  }
+}
+function parseDriftOutput(stdout) {
+  const output = stdout.trim();
+  if (!output) return [];
+  return parseSqlStatements(output).filter((s) => !s.toUpperCase().trimStart().startsWith("--")).map((sql) => {
+    const type = classifyDriftSql(sql);
+    return { sql, type, description: labelDriftType(type) };
+  });
+}
+
+// src/core/adapters/legacy-adapter.ts
+var PrismaLegacyAdapter = class {
+  constructor(version) {
+    this.version = version;
+  }
+  generation = "legacy";
+  getCapabilities() {
+    return {
+      supportsClassicMigrationSql: true,
+      supportsStructuredMigrationPlan: false,
+      supportsContractModel: false,
+      supportsDrift: true,
+      supportsRollbackPlanning: true,
+      supportsExecutedSimulation: true,
+      supportsMigrationHistory: true,
+      isProductionSupported: true,
+      isExperimental: false
+    };
+  }
+  async getMigrationStatus(cwd, schemaPath) {
+    return runPrismaMigrateStatus(cwd, schemaPath);
+  }
+  async detectDrift(cwd, schemaPath, databaseUrl, _provider) {
+    try {
+      const env = databaseUrl ? { ...process.env, DATABASE_URL: databaseUrl } : process.env;
+      const { stdout } = await execPrisma(
+        cwd,
+        [
+          "migrate",
+          "diff",
+          "--from-schema-datamodel",
+          schemaPath,
+          "--to-schema-datasource",
+          schemaPath,
+          "--script"
+        ],
+        { env, timeout: 3e4 }
+      );
+      const items = parseDriftOutput(stdout);
+      return { items, status: items.length > 0 ? "drifted" : "clean" };
+    } catch (err) {
+      const error = err;
+      const stderr = error.stderr ?? "";
+      if (stderr.includes("P1001") || stderr.includes("Can't reach database server") || stderr.includes("Connection refused")) {
+        logger.debug("Drift detection skipped: database unreachable");
+        return { items: [], status: "error", errorMessage: "Database unreachable" };
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      logger.warn({ err }, "Prisma legacy drift detection failed");
+      return { items: [], status: "error", errorMessage: message };
+    }
+  }
+};
+
+// src/core/adapters/prisma7-adapter.ts
+var Prisma7Adapter = class {
+  constructor(version) {
+    this.version = version;
+  }
+  generation = "prisma7";
+  getCapabilities() {
+    return {
+      supportsClassicMigrationSql: true,
+      supportsStructuredMigrationPlan: false,
+      supportsContractModel: false,
+      supportsDrift: true,
+      supportsRollbackPlanning: true,
+      supportsExecutedSimulation: true,
+      supportsMigrationHistory: true,
+      isProductionSupported: true,
+      isExperimental: false
+    };
+  }
+  async getMigrationStatus(cwd, schemaPath) {
+    return runPrismaMigrateStatus(cwd, schemaPath);
+  }
+  async detectDrift(cwd, schemaPath, databaseUrl, _provider) {
+    try {
+      const env = databaseUrl ? { ...process.env, DATABASE_URL: databaseUrl } : process.env;
+      const { stdout } = await execPrisma(
+        cwd,
+        ["migrate", "diff", "--from-schema", schemaPath, "--to-config-datasource", "--script"],
+        { env, timeout: 3e4 }
+      );
+      const items = parseDriftOutput(stdout);
+      return { items, status: items.length > 0 ? "drifted" : "clean" };
+    } catch (err) {
+      const error = err;
+      const stderr = error.stderr ?? "";
+      if (stderr.includes("P1001") || stderr.includes("Can't reach database server") || stderr.includes("Connection refused")) {
+        logger.debug("Drift detection skipped: database unreachable");
+        return { items: [], status: "error", errorMessage: "Database unreachable" };
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      logger.warn({ err }, "Prisma 7 drift detection failed");
+      return { items: [], status: "error", errorMessage: message };
+    }
+  }
+};
+
+// src/core/adapters/prisma8-adapter.ts
+var Prisma8Adapter = class {
+  constructor(version) {
+    this.version = version;
+  }
+  generation = "prisma8";
+  getCapabilities() {
+    return {
+      supportsClassicMigrationSql: false,
+      supportsStructuredMigrationPlan: false,
+      supportsContractModel: false,
+      supportsDrift: false,
+      supportsRollbackPlanning: false,
+      supportsExecutedSimulation: false,
+      supportsMigrationHistory: false,
+      isProductionSupported: false,
+      isExperimental: true
+    };
+  }
+  async getMigrationStatus(_cwd, _schemaPath) {
+    return {
+      verification: "unknown",
+      connected: false,
+      statusMap: /* @__PURE__ */ new Map(),
+      errorCode: "PRISMA8_EXPERIMENTAL_UNSUPPORTED",
+      errorMessage: "Prisma 8 migration verification is experimental and not supported for deployment readiness yet."
+    };
+  }
+  async detectDrift(_cwd, _schemaPath, _databaseUrl, _provider) {
+    return {
+      items: [],
+      status: "not_checked",
+      errorMessage: "Prisma 8 drift detection is experimental and not supported for deployment readiness yet."
+    };
+  }
+};
+
+// src/core/adapters/unsupported-adapter.ts
+var UnsupportedPrismaAdapter = class {
+  constructor(version) {
+    this.version = version;
+  }
+  generation = "unknown";
+  getCapabilities() {
+    return {
+      supportsClassicMigrationSql: false,
+      supportsStructuredMigrationPlan: false,
+      supportsContractModel: false,
+      supportsDrift: false,
+      supportsRollbackPlanning: false,
+      supportsExecutedSimulation: false,
+      supportsMigrationHistory: false,
+      isProductionSupported: false,
+      isExperimental: false
+    };
+  }
+  async getMigrationStatus(_cwd, _schemaPath) {
+    return {
+      verification: "unknown",
+      connected: false,
+      statusMap: /* @__PURE__ */ new Map(),
+      errorCode: "UNSUPPORTED_PRISMA_VERSION",
+      errorMessage: this.version ? `Prisma version "${this.version}" is not supported. Supported versions: Prisma 5, 6, and 7.` : "Prisma version could not be detected or is not supported. Supported versions: Prisma 5, 6, and 7."
+    };
+  }
+  async detectDrift(_cwd, _schemaPath, _databaseUrl, _provider) {
+    return {
+      items: [],
+      status: "not_checked",
+      errorMessage: this.version ? `Drift detection is not supported for Prisma version "${this.version}".` : "Drift detection requires a supported Prisma version (5, 6, or 7)."
+    };
+  }
+};
+
+// src/core/adapters/adapter-factory.ts
+function getPrismaAdapter(version) {
+  if (!version || typeof version !== "string" || !version.trim()) {
+    return new UnsupportedPrismaAdapter(version ?? null);
+  }
+  const clean = version.trim().replace(/^[\^~>=<v\s]+/, "");
+  const firstPart = clean.split(".")[0] ?? "";
+  const major = Number.parseInt(firstPart, 10);
+  if (Number.isNaN(major)) {
+    return new UnsupportedPrismaAdapter(version);
+  }
+  if (major === 5 || major === 6) {
+    return new PrismaLegacyAdapter(version);
+  }
+  if (major === 7) {
+    return new Prisma7Adapter(version);
+  }
+  if (major === 8) {
+    return new Prisma8Adapter(version);
+  }
+  return new UnsupportedPrismaAdapter(version);
+}
+
+// src/core/readiness.ts
+function calculateHealthScore(input) {
+  if (!input.connected || input.migrationVerification === "error") {
+    return 0;
+  }
+  if (input.migrationVerification === "unknown") {
+    return 30;
+  }
+  let score = 100;
+  score -= Math.min(35, input.migrationsFailed * 35);
+  score -= Math.min(25, input.driftCount * 10);
+  score -= Math.min(15, input.migrationsPending * 5);
+  score -= Math.min(30, input.migrationsUnknown * 15);
+  if (input.driftStatus === "error") score -= 25;
+  if (input.hasCriticalRisk || input.maxRiskScore >= 75) score -= 25;
+  else if (input.maxRiskScore >= 50) score -= 15;
+  else if (input.maxRiskScore >= 20) score -= 5;
+  return Math.max(0, Math.min(100, Math.round(score)));
+}
+function evaluateDeploymentReadiness(input) {
+  const healthScore = calculateHealthScore(input);
+  const hasCriticalRisk = input.hasCriticalRisk || input.maxRiskScore >= 75;
+  const isVerified = input.migrationVerification === "verified" && input.migrationsUnknown === 0;
+  const checks = [
+    {
+      id: "database",
+      label: "Database reachable",
+      passed: input.connected,
+      message: input.connected ? "PrismaFlow can reach the configured datasource." : input.errorMessage || "Check DATABASE_URL and database network access before deploying."
+    },
+    {
+      id: "migration-verification",
+      label: "Migration state verified",
+      passed: isVerified,
+      message: isVerified ? "Migration history successfully verified against the database." : input.errorMessage || "Migration state is unknown or unverified. Database state cannot be proven safe."
+    },
+    {
+      id: "drift",
+      label: "No schema drift",
+      passed: input.driftStatus === "clean" && input.driftCount === 0,
+      message: input.driftStatus === "clean" ? "The live database matches the Prisma schema." : input.driftStatus === "drifted" ? `${input.driftCount} drift item${input.driftCount === 1 ? "" : "s"} must be reviewed.` : input.driftStatus === "error" ? "Drift detection failed. Schema differences cannot be verified." : "Drift check not performed (database disconnected or pending migrations exist)."
+    },
+    {
+      id: "failed-migrations",
+      label: "No failed migrations",
+      passed: isVerified && input.migrationsFailed === 0,
+      message: !isVerified ? "Cannot verify failed migration state (verification unproven)." : input.migrationsFailed === 0 ? "Migration history has no failed entries." : `${input.migrationsFailed} failed migration${input.migrationsFailed === 1 ? "" : "s"} need recovery.`
+    },
+    {
+      id: "pending-migrations",
+      label: "No pending migrations",
+      passed: isVerified && input.migrationsPending === 0,
+      message: !isVerified ? "Cannot verify pending migration state (verification unproven)." : input.migrationsPending === 0 ? "All local migrations are applied." : `${input.migrationsPending} migration${input.migrationsPending === 1 ? "" : "s"} still pending.`
+    },
+    {
+      id: "critical-risks",
+      label: "No critical migration risks",
+      passed: !hasCriticalRisk,
+      message: hasCriticalRisk ? "At least one migration contains a critical data-loss operation." : "No critical data-loss operations were detected."
     }
-    const message = error instanceof Error ? error.message : String(error);
-    logger.warn({ err }, "Drift detection failed");
-    return { items: [], status: "error", errorMessage: message };
+  ];
+  const blockers = checks.filter(
+    (check) => !check.passed && ["database", "migration-verification", "failed-migrations", "critical-risks"].includes(
+      check.id
+    )
+  );
+  const hasDriftBlocker = !checks.find((c) => c.id === "drift")?.passed && (input.driftStatus === "drifted" || input.driftStatus === "error");
+  const warnings = checks.filter((check) => !check.passed);
+  if (blockers.length > 0 || hasDriftBlocker) {
+    const summary = !input.connected ? "Blocked: database is unreachable" : !isVerified ? "Blocked: migration verification is unknown or failed" : input.migrationsFailed > 0 ? "Blocked: failed migrations must be resolved" : hasDriftBlocker ? "Blocked: schema drift detected or drift check failed" : "Blocked: critical migration risks detected";
+    return {
+      status: "blocked",
+      score: healthScore,
+      summary,
+      checks
+    };
   }
+  if (warnings.length > 0) {
+    const summary = input.migrationsPending > 0 ? "Attention: pending migrations to review before deploying" : "Attention: review warnings before deploying";
+    return {
+      status: "attention",
+      score: healthScore,
+      summary,
+      checks
+    };
+  }
+  return {
+    status: "ready",
+    score: healthScore,
+    summary: "Ready for deployment",
+    checks
+  };
 }
 
 // src/core/migration-analyzer.ts
@@ -447,7 +964,7 @@ var RISK_PATTERNS = [
     weight: 75
   },
   {
-    pattern: /TRUNCATE/i,
+    pattern: /TRUNCATE\s+TABLE|TRUNCATE\s+\w+/i,
     label: "Truncates table \u2014 full data loss",
     severity: "critical",
     description: "Removes all rows from a table. Cannot be rolled back with standard SQL.",
@@ -463,7 +980,7 @@ var RISK_PATTERNS = [
     weight: 60
   },
   {
-    pattern: /ALTER\s+COLUMN.+NOT\s+NULL/i,
+    pattern: /ALTER\s+COLUMN.+NOT\s+NULL|ALTER\s+TABLE.+ADD\s+COLUMN.+NOT\s+NULL/i,
     label: "Adds NOT NULL constraint",
     severity: "high",
     description: "Adding a NOT NULL constraint will fail if any existing rows have NULL values.",
@@ -515,142 +1032,29 @@ function extractTableName(sql) {
   const match = sql.match(/(?:DROP|TRUNCATE|ALTER)\s+TABLE\s+(?:"?(\w+)"?\.)?"?(\w+)"?/i);
   return match?.[2];
 }
-function analyzeMigrationRisks(sql) {
-  return RISK_PATTERNS.filter(({ pattern }) => pattern.test(sql)).map(({ label }) => label);
-}
-function scoreMigrationRisk(sql) {
-  const matchedPatterns = RISK_PATTERNS.filter(({ pattern }) => pattern.test(sql));
-  const factors = matchedPatterns.map((p) => {
-    const affectedTable = extractTableName(sql);
-    return {
-      pattern: p.pattern.source,
-      severity: p.severity,
-      description: p.description,
-      ...affectedTable !== void 0 ? { affectedTable } : {},
-      recommendation: p.recommendation
-    };
-  });
-  const rawScore = matchedPatterns.reduce((acc, p) => acc + p.weight, 0);
-  const score = Math.min(100, rawScore);
-  let level = "low";
-  if (score >= 75) level = "critical";
-  else if (score >= 50) level = "high";
-  else if (score >= 20) level = "medium";
-  return { score, level, factors };
-}
-function calculateHealthScore(input) {
-  let score = 100;
-  if (!input.connected) score -= 35;
-  score -= Math.min(30, input.migrationsFailed * 25);
-  score -= Math.min(20, input.driftCount * 10);
-  score -= Math.min(15, input.migrationsPending * 5);
-  if (input.maxRiskScore >= 75) score -= 25;
-  else if (input.maxRiskScore >= 50) score -= 18;
-  else if (input.maxRiskScore >= 20) score -= 8;
-  return Math.max(0, Math.min(100, Math.round(score)));
-}
-function buildDeploymentReadiness(input) {
-  const hasCriticalRisk = input.maxRiskScore >= 75;
-  const checks = [
-    {
-      id: "database",
-      label: "Database reachable",
-      passed: input.connected,
-      message: input.connected ? "PrismaFlow can reach the configured datasource." : "Check DATABASE_URL and database network access before deploying."
-    },
-    {
-      id: "drift",
-      label: "No schema drift",
-      passed: input.driftCount === 0,
-      message: input.driftCount === 0 ? "The live database matches the Prisma schema." : `${input.driftCount} drift item${input.driftCount === 1 ? "" : "s"} must be reviewed.`
-    },
-    {
-      id: "failed-migrations",
-      label: "No failed migrations",
-      passed: input.migrationsFailed === 0,
-      message: input.migrationsFailed === 0 ? "Migration history has no failed entries." : `${input.migrationsFailed} failed migration${input.migrationsFailed === 1 ? "" : "s"} need recovery.`
-    },
-    {
-      id: "pending-migrations",
-      label: "No pending migrations",
-      passed: input.migrationsPending === 0,
-      message: input.migrationsPending === 0 ? "All local migrations are applied." : `${input.migrationsPending} migration${input.migrationsPending === 1 ? "" : "s"} still pending.`
-    },
-    {
-      id: "critical-risks",
-      label: "No critical migration risks",
-      passed: !hasCriticalRisk,
-      message: hasCriticalRisk ? "At least one migration contains a critical data-loss operation." : "No critical data-loss operations were detected."
-    }
-  ];
-  const blockers = checks.filter(
-    (check) => !check.passed && ["database", "drift", "failed-migrations", "critical-risks"].includes(check.id)
-  );
-  const warnings = checks.filter((check) => !check.passed);
-  if (blockers.length > 0) {
-    return {
-      status: "blocked",
-      score: input.healthScore,
-      summary: "Not ready for deployment",
-      checks
-    };
-  }
-  if (warnings.length > 0) {
+function analyzeMigrationRisks(sql) {
+  return RISK_PATTERNS.filter(({ pattern }) => pattern.test(sql)).map(({ label }) => label);
+}
+function scoreMigrationRisk(sql) {
+  const matchedPatterns = RISK_PATTERNS.filter(({ pattern }) => pattern.test(sql));
+  const factors = matchedPatterns.map((p) => {
+    const affectedTable = extractTableName(sql);
     return {
-      status: "attention",
-      score: input.healthScore,
-      summary: "Review pending work before deployment",
-      checks
+      pattern: p.pattern.source,
+      severity: p.severity,
+      description: p.description,
+      ...affectedTable !== void 0 ? { affectedTable } : {},
+      recommendation: p.recommendation
     };
-  }
-  return {
-    status: "ready",
-    score: input.healthScore,
-    summary: "Ready for deployment",
-    checks
-  };
-}
-async function getMigrationStatusMap(cwd, schemaPath) {
-  const map = /* @__PURE__ */ new Map();
-  let stdout = "";
-  try {
-    const result = await execPrisma(cwd, ["migrate", "status", "--schema", schemaPath], {
-      timeout: 3e4
-    });
-    stdout = result.stdout;
-    return map;
-  } catch (err) {
-    const error = err;
-    stdout = error.stdout ?? "";
-    const stderr = error.stderr ?? "";
-    if (stderr.includes("P1001") || stderr.includes("Can't reach database server") || stderr.includes("Connection refused")) {
-      throw new Error("DATABASE_UNREACHABLE");
-    }
-    logger.debug({ stdout, stderr }, "prisma migrate status exited non-zero \u2014 parsing output");
-  }
-  const lines = stdout.split("\n");
-  let mode = "none";
-  for (const rawLine of lines) {
-    const line = rawLine.trim();
-    if (line.includes("have not yet been applied")) {
-      mode = "pending";
-      continue;
-    }
-    if (line.match(/failed to apply|rolled back|migration.*failed/i)) {
-      mode = "failed";
-      continue;
-    }
-    if (line === "" || line.startsWith("\u2500") || line.startsWith("The following")) {
-      mode = "none";
-      continue;
-    }
-    if (mode === "none") continue;
-    const cleaned = line.replace(/^[•\-*]\s*/, "").trim();
-    if (cleaned.match(/^\d{14}/)) {
-      map.set(cleaned, mode === "pending" ? "pending" : "failed");
-    }
-  }
-  return map;
+  });
+  const rawScore = matchedPatterns.reduce((acc, p) => acc + p.weight, 0);
+  const score = Math.min(100, rawScore);
+  const hasCriticalFactor = matchedPatterns.some((pattern) => pattern.severity === "critical");
+  let level = "low";
+  if (hasCriticalFactor || score >= 75) level = "critical";
+  else if (score >= 50) level = "high";
+  else if (score >= 20) level = "medium";
+  return { score, level, factors };
 }
 async function getMigrationDetails(cwd, name) {
   const project = await detectPrismaProject(cwd);
@@ -670,15 +1074,16 @@ async function getMigrationDetails(cwd, name) {
 async function getMigrations(cwd) {
   const project = await detectPrismaProject(cwd);
   if (!project) return [];
-  let statusMap;
-  try {
-    statusMap = await getMigrationStatusMap(cwd, project.schemaPath);
-  } catch {
-    statusMap = /* @__PURE__ */ new Map();
-  }
+  const adapter = getPrismaAdapter(project.prismaVersion);
+  const statusResult = await adapter.getMigrationStatus(cwd, project.schemaPath);
   return Promise.all(
     project.migrations.map(async (m) => {
-      const status = statusMap.get(m.name) ?? "applied";
+      let status = "unknown";
+      if (statusResult.verification === "verified") {
+        status = statusResult.statusMap.get(m.name) ?? "applied";
+      } else {
+        status = statusResult.statusMap.get(m.name) ?? "unknown";
+      }
       let sql = "";
       try {
         sql = await fs4.readFile(m.sqlPath, "utf-8");
@@ -693,65 +1098,58 @@ async function getMigrations(cwd) {
 async function getProjectStatus(cwd) {
   const project = await detectPrismaProject(cwd);
   if (!project) throw new Error("No Prisma project found");
-  let connected = false;
-  try {
-    await execPrisma(cwd, ["migrate", "status", "--schema", project.schemaPath], {
-      timeout: 3e4
-    });
-    connected = true;
-  } catch (err) {
-    const error = err;
-    const stderr = error.stderr ?? "";
-    if (stderr.includes("P1001") || stderr.includes("Can't reach database server") || stderr.includes("Connection refused")) {
-      connected = false;
-    } else {
-      connected = true;
-    }
-  }
+  const adapter = getPrismaAdapter(project.prismaVersion);
+  const statusResult = await adapter.getMigrationStatus(cwd, project.schemaPath);
   const migrations = await getMigrations(cwd);
   const migrationsPending = migrations.filter((m) => m.status === "pending").length;
   const migrationsFailed = migrations.filter((m) => m.status === "failed").length;
+  const migrationsUnknown = migrations.filter((m) => m.status === "unknown").length;
   const migrationsApplied = migrations.filter((m) => m.status === "applied").length;
-  let driftResult = { items: [], status: "clean" };
-  if (connected) {
+  let driftResult = { items: [], status: "not_checked" };
+  if (statusResult.connected && statusResult.verification === "verified" && migrationsPending === 0) {
     driftResult = await detectDrift(cwd);
   }
   const hasDrift = driftResult.status === "drifted";
   let riskLevel = "low";
-  if (migrationsFailed > 0) riskLevel = "high";
-  else if (hasDrift) riskLevel = "medium";
+  if (migrationsFailed > 0 || statusResult.verification === "error") riskLevel = "high";
+  else if (hasDrift || statusResult.verification === "unknown") riskLevel = "medium";
   else if (migrationsPending > 0) riskLevel = "low";
   const maxRiskScore = Math.max(0, ...migrations.map((m) => m.riskScore.score));
-  if (maxRiskScore >= 75) riskLevel = "critical";
+  const hasCriticalRisk = migrations.some(
+    (m) => m.riskScore.level === "critical" || m.riskScore.factors.some((factor) => factor.severity === "critical")
+  );
+  if (hasCriticalRisk || maxRiskScore >= 75) riskLevel = "critical";
   else if (maxRiskScore >= 50) riskLevel = "high";
   else if (maxRiskScore >= 20 && riskLevel === "low") riskLevel = "medium";
-  const healthScore = calculateHealthScore({
-    connected,
-    migrationsPending,
-    migrationsFailed,
-    driftCount: driftResult.items.length,
-    maxRiskScore
-  });
-  const deploymentReadiness = buildDeploymentReadiness({
-    connected,
+  const deploymentReadiness = evaluateDeploymentReadiness({
+    connected: statusResult.connected,
+    migrationVerification: statusResult.verification,
+    migrationsApplied,
     migrationsPending,
     migrationsFailed,
+    migrationsUnknown,
+    driftStatus: driftResult.status,
     driftCount: driftResult.items.length,
     maxRiskScore,
-    healthScore
+    hasCriticalRisk,
+    errorMessage: statusResult.errorMessage ?? driftResult.errorMessage
   });
   return {
-    connected,
-    migrationsApplied: connected ? migrationsApplied : 0,
-    migrationsPending: connected ? migrationsPending : migrations.length,
+    connected: statusResult.connected,
+    migrationVerification: statusResult.verification,
+    migrationsApplied: statusResult.connected ? migrationsApplied : 0,
+    migrationsPending: statusResult.connected ? migrationsPending : migrations.length,
     migrationsFailed,
+    migrationsUnknown,
     driftDetected: hasDrift,
     driftCount: driftResult.items.length,
+    driftStatus: driftResult.status,
     riskLevel,
-    healthScore,
+    healthScore: deploymentReadiness.score,
     deploymentReadiness,
     lastSync: (/* @__PURE__ */ new Date()).toISOString(),
     ...project.provider ? { provider: project.provider } : {},
+    projectName: "prisma-project",
     schemaPath: project.schemaPath,
     migrationsPath: project.migrationsPath,
     ...project.prismaVersion ? { prismaVersion: project.prismaVersion } : {},
@@ -796,9 +1194,9 @@ async function trackEvent(event, migrationCount) {
 
 // src/commands/check.ts
 function checkCommand() {
-  return new Command("check").description("Validate database migration state (CI-friendly)").option("--ci", "Exit with a non-zero code when issues are found (for CI pipelines)").option("--json", "Output result as JSON to stdout").option(
+  return new Command("check").description("Validate database migration state and deployment readiness (CI-friendly)").option("--ci", "Exit with a non-zero code when issues or unverified states are found").option("--json", "Output result as JSON to stdout").option(
     "--fail-on-risk <level>",
-    "Exit code 5 when risk meets or exceeds this level (low|medium|high|critical)"
+    "Exit code 5 when estimated risk meets or exceeds this level (low|medium|high|critical)"
   ).option("--quiet", "Suppress non-essential output").action(
     async (options) => {
       const cwd = process.cwd();
@@ -820,14 +1218,18 @@ function checkCommand() {
           getProjectStatus(cwd),
           getMigrations(cwd)
         ]);
-        const ok = status.migrationsFailed === 0 && !status.driftDetected && status.migrationsPending === 0;
+        const isVerified = status.migrationVerification === "verified" && status.connected;
+        const ok = isVerified && status.migrationsFailed === 0 && !status.driftDetected && status.migrationsPending === 0;
         const result = {
           ok,
           connected: status.connected,
+          migrationVerification: status.migrationVerification,
           pendingCount: status.migrationsPending,
           failedCount: status.migrationsFailed,
+          unknownCount: status.migrationsUnknown,
           driftDetected: status.driftDetected,
           driftCount: status.driftCount,
+          driftStatus: status.driftStatus,
           riskLevel: status.riskLevel,
           healthScore: status.healthScore,
           deploymentReadiness: status.deploymentReadiness,
@@ -849,6 +1251,13 @@ function checkCommand() {
           } else {
             console.log(chalk.red(" \u2716  Database unreachable \u2014 check DATABASE_URL"));
           }
+          if (status.migrationVerification === "verified") {
+            console.log(chalk.green(" \u2714  Migration verification: verified"));
+          } else {
+            console.log(
+              chalk.red(` \u2716  Migration verification: ${status.migrationVerification}`) + chalk.dim(" (cannot prove database safety)")
+            );
+          }
           console.log(
             chalk.green(" \u2714  Applied migrations: ") + chalk.bold(String(status.migrationsApplied))
           );
@@ -884,6 +1293,10 @@ function checkCommand() {
               )
             );
             console.log(chalk.dim("     Review the dashboard Drift page before deploying"));
+          } else if (status.driftStatus === "not_checked") {
+            console.log(
+              chalk.yellow(" \u26A0  Schema drift: not checked (pending work or disconnected)")
+            );
           } else {
             console.log(chalk.green(" \u2714  No schema drift detected"));
           }
@@ -894,25 +1307,33 @@ function checkCommand() {
             critical: chalk.red
           };
           const riskColor = riskColors[status.riskLevel] ?? chalk.white;
-          console.log(` \u{1F512}  Risk level: ${riskColor(chalk.bold(status.riskLevel.toUpperCase()))}`);
+          console.log(
+            ` \u{1F512}  Estimated risk: ${riskColor(chalk.bold(status.riskLevel.toUpperCase()))}`
+          );
           console.log(
             ` \u{1F6A6}  Readiness: ${riskColor(chalk.bold(`${status.healthScore}/100`))}${chalk.dim(
               ` \u2014 ${status.deploymentReadiness.summary}`
             )}`
           );
-          const highestRiskMigration = migrations.filter((m) => m.riskScore.score > 0).sort((a, b) => b.riskScore.score - a.riskScore.score)[0];
-          if (highestRiskMigration?.riskScore.factors.length) {
+          const highestRiskMigration2 = migrations.filter((m) => m.riskScore.score > 0).sort((a, b) => b.riskScore.score - a.riskScore.score)[0];
+          if (highestRiskMigration2?.riskScore.factors.length) {
             console.log(chalk.dim(`
-     Top risk in ${highestRiskMigration.name}:`));
-            for (const factor of highestRiskMigration.riskScore.factors.slice(0, 2)) {
+     Top heuristic risk in ${highestRiskMigration2.name}:`));
+            for (const factor of highestRiskMigration2.riskScore.factors.slice(0, 2)) {
               console.log(chalk.dim(`       \u2022 ${factor.description}`));
             }
           }
           console.log(bar);
           if (ok) {
-            console.log(chalk.bold.green(" \u2714  All checks passed"));
+            console.log(chalk.bold.green(" \u2714  All checks passed and verified"));
           } else {
             console.log(chalk.bold.red(" \u2716  Issues detected \u2014 review above"));
+            if (!status.connected) {
+              console.log(chalk.dim("     \u2192 Fix: Check database connection and DATABASE_URL"));
+            }
+            if (status.migrationVerification !== "verified") {
+              console.log(chalk.dim("     \u2192 Fix: Run prisma-flow doctor to diagnose Prisma CLI"));
+            }
             if (status.migrationsFailed > 0) {
               console.log(chalk.dim("     \u2192 Fix: Run prisma migrate resolve"));
             }
@@ -949,6 +1370,7 @@ function checkCommand() {
           if (current >= threshold) process.exit(5);
         }
         if (options.ci) {
+          if (!status.connected || status.migrationVerification !== "verified") process.exit(4);
           if (status.migrationsFailed > 0) process.exit(3);
           if (status.driftDetected) process.exit(2);
           if (status.migrationsPending > 0) process.exit(1);
@@ -980,7 +1402,486 @@ import { Command as Command2 } from "commander";
 import fs5 from "fs";
 import path4 from "path";
 import { pathToFileURL } from "url";
-import { PrismaFlowConfigSchema } from "@prisma-flow/shared";
+
+// ../shared/dist/index.js
+import { z } from "zod";
+var MigrationStatusSchema = z.enum(["applied", "pending", "failed", "unknown"]);
+var MigrationVerificationStatusSchema = z.enum(["verified", "unknown", "error"]);
+var RiskLevelSchema = z.enum(["low", "medium", "high", "critical"]);
+var DriftTypeSchema = z.enum([
+  "table-missing",
+  "table-extra",
+  "column-mismatch",
+  "index-change",
+  "constraint-change",
+  "unknown",
+  "missing_migration",
+  "extra_column",
+  "extra_table",
+  "modified_migration"
+]);
+var DriftDetectionStatusSchema = z.enum(["clean", "drifted", "error", "not_checked"]);
+var LogLevelSchema = z.enum(["trace", "debug", "info", "warn", "error"]);
+var WebhookTypeSchema = z.enum(["slack", "discord", "http"]);
+var WebhookEventSchema = z.enum([
+  "drift-detected",
+  "migration-failed",
+  "check-complete",
+  "migration-applied",
+  "simulation-complete",
+  "risk-threshold-exceeded"
+]);
+var DatabaseProviderSchema = z.enum([
+  "postgresql",
+  "mysql",
+  "sqlite",
+  "sqlserver",
+  "mongodb"
+]);
+var DriftRepairStrategySchema = z.enum([
+  "reconcile_history",
+  "manual_migration",
+  "manual_sql",
+  "review_only"
+]);
+var SchemaDiffTypeSchema = z.enum([
+  "model_added",
+  "model_removed",
+  "field_added",
+  "field_removed",
+  "field_type_changed",
+  "added",
+  "removed",
+  "modified"
+]);
+var SimulationVerificationSchema = z.enum(["executed", "static-analysis", "not-verified"]);
+var SimulationOutcomeSchema = z.enum(["success", "failure", "unknown"]);
+var SimulationModeSchema = z.enum(["static", "shadow", "live"]);
+var SimulationStatementTypeSchema = z.enum([
+  "CREATE_TABLE",
+  "ALTER_TABLE",
+  "DROP_TABLE",
+  "CREATE_INDEX",
+  "DROP_INDEX",
+  "INSERT",
+  "UPDATE",
+  "DELETE",
+  "TRUNCATE",
+  "OTHER"
+]);
+var DeploymentReadinessStatusSchema = z.enum(["ready", "attention", "blocked"]);
+var DeploymentReadinessCheckIdSchema = z.enum([
+  "database",
+  "drift",
+  "migration-verification",
+  "failed-migrations",
+  "pending-migrations",
+  "critical-risks"
+]);
+var DeploymentPlanPrioritySchema = z.enum(["blocker", "recommended", "optional"]);
+var MigrationSchema = z.object({
+  name: z.string().min(1),
+  timestamp: z.string(),
+  status: MigrationStatusSchema,
+  sqlPath: z.string(),
+  createdAt: z.string().optional(),
+  appliedAt: z.string().optional(),
+  durationMs: z.number().int().nonnegative().optional()
+});
+var RiskFactorSchema = z.object({
+  pattern: z.string(),
+  severity: RiskLevelSchema,
+  description: z.string(),
+  affectedTable: z.string().optional(),
+  estimatedRows: z.number().int().nonnegative().optional(),
+  recommendation: z.string()
+});
+var MigrationRiskScoreSchema = z.object({
+  score: z.number().int().min(0).max(100),
+  level: RiskLevelSchema,
+  factors: z.array(RiskFactorSchema)
+});
+var RollbackStepSchema = z.object({
+  index: z.number().int().nonnegative(),
+  forwardSql: z.string(),
+  rollbackSql: z.string(),
+  automated: z.boolean(),
+  warning: z.string().optional()
+});
+var RollbackPlanSchema = z.object({
+  migrationName: z.string(),
+  steps: z.array(RollbackStepSchema).default([]),
+  hasManualSteps: z.boolean().default(false),
+  warnings: z.array(z.string()).default([]),
+  generatedAt: z.string(),
+  automated: z.boolean().default(false),
+  sql: z.string().optional()
+});
+var MigrationDetailSchema = MigrationSchema.extend({
+  sql: z.string(),
+  risks: z.array(z.string()),
+  riskScore: MigrationRiskScoreSchema.optional(),
+  rollbackPlan: RollbackPlanSchema.optional(),
+  gitBranch: z.string().optional()
+});
+var DriftItemSchema = z.object({
+  sql: z.string(),
+  type: DriftTypeSchema,
+  description: z.string(),
+  identifier: z.string().optional(),
+  migrationName: z.string().optional()
+});
+var DriftResultSchema = z.object({
+  hasDrift: z.boolean(),
+  driftCount: z.number().int().nonnegative(),
+  differences: z.array(DriftItemSchema),
+  cachedAt: z.string().nullable(),
+  status: DriftDetectionStatusSchema,
+  errorMessage: z.string().optional()
+});
+var DeploymentReadinessCheckSchema = z.object({
+  id: DeploymentReadinessCheckIdSchema,
+  label: z.string(),
+  passed: z.boolean(),
+  message: z.string()
+});
+var DeploymentReadinessSchema = z.object({
+  status: DeploymentReadinessStatusSchema,
+  score: z.number().int().min(0).max(100),
+  summary: z.string(),
+  checks: z.array(DeploymentReadinessCheckSchema)
+});
+var DeploymentPlanActionSchema = z.object({
+  priority: DeploymentPlanPrioritySchema,
+  title: z.string(),
+  detail: z.string(),
+  command: z.string().optional(),
+  href: z.string().optional()
+});
+var DeploymentPlanCommandSchema = z.object({
+  label: z.string(),
+  command: z.string(),
+  reason: z.string()
+});
+var DeploymentPlanMigrationSummarySchema = z.object({
+  total: z.number().int().nonnegative(),
+  applied: z.number().int().nonnegative(),
+  pending: z.number().int().nonnegative(),
+  failed: z.number().int().nonnegative(),
+  unknown: z.number().int().nonnegative().default(0),
+  verification: MigrationVerificationStatusSchema.default("verified"),
+  pendingNames: z.array(z.string()),
+  failedNames: z.array(z.string()),
+  highestRisk: z.object({
+    name: z.string(),
+    level: RiskLevelSchema,
+    score: z.number().int().min(0).max(100),
+    factors: z.array(RiskFactorSchema)
+  }).optional()
+});
+var DeploymentPlanDriftSummarySchema = z.object({
+  status: DriftDetectionStatusSchema,
+  detected: z.boolean(),
+  count: z.number().int().nonnegative(),
+  errorMessage: z.string().optional()
+});
+var DeploymentPlanSchema = z.object({
+  schemaVersion: z.literal("prismaflow-plan/v1"),
+  generatedAt: z.string(),
+  decision: DeploymentReadinessStatusSchema,
+  score: z.number().int().min(0).max(100),
+  summary: z.string(),
+  project: z.object({
+    schemaPath: z.string(),
+    migrationsPath: z.string(),
+    provider: DatabaseProviderSchema.optional(),
+    prismaVersion: z.string().optional(),
+    packageManager: z.string().optional(),
+    hasDatabaseUrl: z.boolean()
+  }),
+  checks: z.array(DeploymentReadinessCheckSchema),
+  migrations: DeploymentPlanMigrationSummarySchema,
+  drift: DeploymentPlanDriftSummarySchema,
+  actions: z.array(DeploymentPlanActionSchema),
+  commands: z.array(DeploymentPlanCommandSchema),
+  valueHighlights: z.array(z.string())
+});
+var ProjectStatusSchema = z.object({
+  connected: z.boolean(),
+  migrationVerification: MigrationVerificationStatusSchema.default("verified"),
+  migrationsApplied: z.number().int().nonnegative(),
+  migrationsPending: z.number().int().nonnegative(),
+  migrationsFailed: z.number().int().nonnegative(),
+  migrationsUnknown: z.number().int().nonnegative().default(0),
+  driftDetected: z.boolean(),
+  driftCount: z.number().int().nonnegative(),
+  driftStatus: DriftDetectionStatusSchema.default("clean"),
+  riskLevel: RiskLevelSchema,
+  healthScore: z.number().int().min(0).max(100),
+  deploymentReadiness: DeploymentReadinessSchema,
+  lastSync: z.string(),
+  provider: DatabaseProviderSchema.optional(),
+  projectName: z.string().optional(),
+  schemaPath: z.string().optional(),
+  migrationsPath: z.string().optional(),
+  prismaVersion: z.string().optional(),
+  packageManager: z.string().optional(),
+  hasDatabaseUrl: z.boolean().optional()
+});
+var SimulationStatementSchema = z.object({
+  index: z.number().int().nonnegative(),
+  sql: z.string(),
+  type: SimulationStatementTypeSchema,
+  isDestructive: z.boolean(),
+  warnings: z.array(z.string()),
+  estimatedRowsAffected: z.number().optional(),
+  success: z.boolean().optional(),
+  error: z.string().optional(),
+  durationMs: z.number().nonnegative().optional()
+});
+var SimulationResultSchema = z.object({
+  migrationName: z.string(),
+  verification: SimulationVerificationSchema,
+  outcome: SimulationOutcomeSchema,
+  statements: z.array(SimulationStatementSchema),
+  destructiveStatements: z.number().int().nonnegative(),
+  warnings: z.array(z.string()),
+  simulatedAt: z.string(),
+  error: z.string().optional(),
+  mode: SimulationModeSchema.optional()
+});
+var DriftRecoverySuggestionSchema = z.object({
+  driftItem: DriftItemSchema,
+  strategy: DriftRepairStrategySchema,
+  description: z.string(),
+  sql: z.string().optional(),
+  automated: z.literal(false).default(false),
+  risk: RiskLevelSchema,
+  warnings: z.array(z.string()).default([])
+});
+var DriftRepairPlanSchema = z.object({
+  generatedAt: z.string(),
+  driftCount: z.number().int().nonnegative(),
+  suggestions: z.array(DriftRecoverySuggestionSchema),
+  isMutatingDisabled: z.literal(true).default(true)
+});
+var SchemaDiffSchema = z.object({
+  type: SchemaDiffTypeSchema,
+  modelName: z.string().optional(),
+  fieldName: z.string().optional(),
+  oldType: z.string().optional(),
+  newType: z.string().optional(),
+  description: z.string(),
+  breaking: z.boolean(),
+  entity: z.string().optional(),
+  field: z.string().optional(),
+  before: z.string().optional(),
+  after: z.string().optional()
+});
+var MigrationHistoryDiffSchema = z.object({
+  sourceEnv: z.string(),
+  targetEnv: z.string(),
+  sourceApplied: z.number().int().nonnegative(),
+  targetApplied: z.number().int().nonnegative(),
+  onlyInSource: z.array(z.string()),
+  onlyInTarget: z.array(z.string()),
+  divergencePoint: z.string().optional(),
+  inSync: z.boolean(),
+  name: z.string().optional(),
+  presentInSource: z.boolean().optional(),
+  presentInTarget: z.boolean().optional(),
+  statusInSource: MigrationStatusSchema.optional(),
+  statusInTarget: MigrationStatusSchema.optional()
+});
+var EnvironmentComparisonEntrySchema = z.object({
+  name: z.string(),
+  reachable: z.boolean(),
+  appliedCount: z.number().int().nonnegative(),
+  pendingCount: z.number().int().nonnegative(),
+  failedCount: z.number().int().nonnegative()
+});
+var EnvironmentComparisonSchema = z.object({
+  referenceEnv: z.string(),
+  environments: z.array(EnvironmentComparisonEntrySchema),
+  diffs: z.array(MigrationHistoryDiffSchema),
+  allInSync: z.boolean(),
+  comparedAt: z.string(),
+  source: z.string().optional(),
+  target: z.string().optional(),
+  schemaDiffs: z.array(SchemaDiffSchema).optional(),
+  migrationDiffs: z.array(MigrationHistoryDiffSchema).optional()
+});
+var GitMigrationInfoSchema = z.object({
+  migrationName: z.string(),
+  committed: z.boolean(),
+  commitHash: z.string().optional(),
+  commitAuthor: z.string().optional(),
+  commitDate: z.string().optional(),
+  commitMessage: z.string().optional(),
+  branch: z.string().optional(),
+  authorName: z.string().optional(),
+  committedAt: z.string().optional()
+});
+var MigrationConflictSchema = z.object({
+  timestamp: z.string(),
+  migrations: z.array(z.string()),
+  type: z.enum(["duplicate_timestamp", "timestamp-overlap", "name-conflict", "history-diverge"]),
+  description: z.string(),
+  migrationA: z.string().optional(),
+  migrationB: z.string().optional(),
+  branches: z.array(z.string()).optional(),
+  conflictType: z.enum(["timestamp-overlap", "name-conflict", "history-diverge"]).optional()
+});
+var AuditActionSchema = z.enum([
+  "dashboard.start",
+  "status.check",
+  "drift.detect",
+  "drift.repair",
+  "migration.check",
+  "migration.apply",
+  "migration.simulate",
+  "migration.rollback",
+  "migration.inspect",
+  "migration.history",
+  "migration.create",
+  "deployment.plan",
+  "doctor.run",
+  "env.compare",
+  "schema.diff"
+]);
+var AuditEntrySchema = z.object({
+  timestamp: z.string(),
+  action: AuditActionSchema,
+  cwd: z.string(),
+  result: z.enum(["success", "failure", "warning"]),
+  detail: z.record(z.unknown()).optional()
+});
+var PaginationQuerySchema = z.object({
+  page: z.coerce.number().int().positive().default(1),
+  limit: z.coerce.number().int().positive().max(100).default(20)
+});
+var PaginationMetaSchema = z.object({
+  page: z.number().int().positive(),
+  limit: z.number().int().positive(),
+  total: z.number().int().nonnegative(),
+  pages: z.number().int().nonnegative()
+});
+var WebhookConfigSchema = z.object({
+  type: WebhookTypeSchema,
+  url: z.string().url(),
+  events: z.array(WebhookEventSchema).optional()
+});
+var FeatureFlagsSchema = z.object({
+  riskAnalysis: z.boolean().default(true),
+  webhookAlerts: z.boolean().default(false),
+  auditLog: z.boolean().default(false),
+  ciAnnotations: z.boolean().default(true),
+  envComparison: z.boolean().default(false),
+  rollbackGen: z.boolean().default(false),
+  simulation: z.boolean().default(true),
+  gitAwareness: z.boolean().default(false)
+});
+var EnvironmentEntrySchema = z.object({
+  name: z.string().min(1),
+  databaseUrl: z.string().url().or(z.string().startsWith("file:"))
+});
+var PrismaFlowConfigSchema = z.object({
+  port: z.number().int().positive().max(65535).default(5555),
+  logLevel: LogLevelSchema.default("info"),
+  openBrowser: z.boolean().default(true),
+  features: FeatureFlagsSchema.partial().default({}),
+  webhooks: z.array(WebhookConfigSchema).default([]),
+  environments: z.array(EnvironmentEntrySchema).default([]),
+  auditLogMaxMb: z.number().positive().default(10),
+  riskThreshold: RiskLevelSchema.default("medium")
+});
+var SSEEventTypeSchema = z.enum([
+  "status-update",
+  "drift-detected",
+  "drift-resolved",
+  "migration-applied",
+  "migration-failed",
+  "simulation-progress",
+  "simulation-complete",
+  "repair-progress",
+  "repair-complete"
+]);
+var SSEEventSchema = z.object({
+  type: SSEEventTypeSchema,
+  data: z.unknown(),
+  timestamp: z.string()
+});
+var SchemaFieldSchema = z.object({
+  name: z.string(),
+  type: z.string(),
+  kind: z.string(),
+  isId: z.boolean(),
+  isRequired: z.boolean(),
+  isList: z.boolean(),
+  isUnique: z.boolean(),
+  hasDefaultValue: z.boolean(),
+  default: z.unknown().optional(),
+  relationName: z.string().optional(),
+  relationFromFields: z.array(z.string()).optional(),
+  relationToFields: z.array(z.string()).optional()
+});
+var SchemaModelSchema = z.object({
+  name: z.string(),
+  dbName: z.string().nullable().optional(),
+  fields: z.array(SchemaFieldSchema),
+  primaryKey: z.unknown().nullable().optional(),
+  uniqueFields: z.array(z.array(z.string())).optional(),
+  uniqueIndexes: z.array(z.unknown()).optional()
+});
+var SchemaEnumSchema = z.object({
+  name: z.string(),
+  values: z.array(
+    z.union([z.string(), z.object({ name: z.string(), dbName: z.string().nullable().optional() })])
+  )
+});
+var SchemaDatamodelSchema = z.object({
+  models: z.array(SchemaModelSchema),
+  enums: z.array(SchemaEnumSchema),
+  types: z.array(z.unknown()).optional()
+});
+var PrismaFlowError = class extends Error {
+  constructor(message, code, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = "PrismaFlowError";
+  }
+};
+var SimulationError = class extends PrismaFlowError {
+  constructor(migrationName, cause) {
+    super(`Migration simulation failed for "${migrationName}".`, "SIMULATION_FAILED", cause);
+    this.name = "SimulationError";
+  }
+};
+var RollbackError = class extends PrismaFlowError {
+  constructor(migrationName, detail) {
+    super(`Rollback failed for "${migrationName}": ${detail}`, "ROLLBACK_FAILED");
+    this.name = "RollbackError";
+  }
+};
+var EnvironmentComparisonError = class extends PrismaFlowError {
+  constructor(source, target, cause) {
+    super(
+      `Environment comparison failed between "${source}" and "${target}".`,
+      "ENV_COMPARISON_FAILED",
+      cause
+    );
+    this.name = "EnvironmentComparisonError";
+  }
+};
+var GitAwarenessError = class extends PrismaFlowError {
+  constructor(detail, cause) {
+    super(`Git awareness error: ${detail}`, "GIT_AWARENESS_ERROR", cause);
+    this.name = "GitAwarenessError";
+  }
+};
+
+// src/core/config-loader.ts
 var _cached = null;
 var _cachedCwd = null;
 function applyEnvOverrides(config) {
@@ -1080,8 +1981,7 @@ function getConfigSync() {
 }
 
 // src/core/env-comparator.ts
-import { EnvironmentComparisonError } from "@prisma-flow/shared";
-function parseStatusOutput(output) {
+function parseStatusOutput2(output) {
   const applied = [];
   const pending = [];
   const failed = [];
@@ -1115,13 +2015,13 @@ async function queryMigrationStatus(envName, databaseUrl, schemaPath, cwd) {
       env,
       timeout: 3e4
     });
-    return { ...parseStatusOutput(stdout), reachable: true };
+    return { ...parseStatusOutput2(stdout), reachable: true };
   } catch (err) {
     const error = err instanceof Error ? err : new Error(String(err));
     if ("stdout" in err) {
       const output = err.stdout ?? "";
       if (output.length > 0) {
-        return { ...parseStatusOutput(output), reachable: true };
+        return { ...parseStatusOutput2(output), reachable: true };
       }
     }
     if (error.message.includes("P1001") || error.message.includes("Connection refused") || error.message.includes("Can't reach database server")) {
@@ -1323,12 +2223,12 @@ import open from "open";
 
 // src/server/index.ts
 import { randomBytes } from "crypto";
-import fs12 from "fs";
-import path11 from "path";
+import fs11 from "fs";
+import path10 from "path";
 import { fileURLToPath } from "url";
 import { serve } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
-import { Hono as Hono15 } from "hono";
+import { Hono as Hono16 } from "hono";
 import { cors } from "hono/cors";
 import { secureHeaders } from "hono/secure-headers";
 
@@ -1422,21 +2322,15 @@ import { Hono as Hono4 } from "hono";
 // src/core/schema-differ.ts
 import fs7 from "fs/promises";
 async function diffSchemaVsDatabase(schemaPath, databaseUrl, cwd) {
-  const env = { ...process.env, DATABASE_URL: databaseUrl };
+  const normalizedDatabaseUrl = normalizeDatabaseUrlForPrismaCommand(databaseUrl, schemaPath);
+  const env = { ...process.env, DATABASE_URL: normalizedDatabaseUrl };
   try {
-    const { stdout } = await execPrisma(
-      cwd,
-      [
-        "migrate",
-        "diff",
-        "--from-schema-datamodel",
-        schemaPath,
-        "--to-database-url",
-        databaseUrl,
-        "--script"
-      ],
-      { env, timeout: 3e4 }
-    );
+    const { stdout } = await execPrismaMigrateDiff(cwd, {
+      fromSchema: schemaPath,
+      legacyDestinationArgs: ["--to-database-url", normalizedDatabaseUrl],
+      env,
+      timeout: 3e4
+    });
     const diffs = parseSqlDiff(stdout);
     return { sql: stdout, diffs };
   } catch (err) {
@@ -1625,12 +2519,11 @@ import { Hono as Hono7 } from "hono";
 import { execFile as execFile2 } from "child_process";
 import fs8 from "fs/promises";
 import path6 from "path";
-import { promisify as promisify2 } from "util";
-import { GitAwarenessError } from "@prisma-flow/shared";
-var execAsync = promisify2(execFile2);
-async function git(args, cwd) {
+import { promisify } from "util";
+var execAsync = promisify(execFile2);
+async function git(args2, cwd) {
   try {
-    const { stdout } = await execAsync("git", args, { cwd, timeout: 1e4 });
+    const { stdout } = await execAsync("git", args2, { cwd, timeout: 1e4 });
     return stdout.trim();
   } catch (err) {
     const error = err instanceof Error ? err : new Error(String(err));
@@ -1809,112 +2702,365 @@ app8.get("/:name", async (c) => {
 });
 var migrations_default = app8;
 
-// src/server/routes/repair.ts
+// src/server/routes/plan.ts
 import { Hono as Hono9 } from "hono";
 
-// src/core/drift-recovery.ts
-import fs9 from "fs/promises";
-import path7 from "path";
-import { DriftRepairError } from "@prisma-flow/shared";
-function generateRepairSuggestions(driftItems, migrationsDir) {
-  void migrationsDir;
-  const suggestions = [];
-  for (const item of driftItems) {
-    const strategy = pickStrategy(item);
-    const repairSql = generateRepairSql(item, strategy);
-    suggestions.push({
-      driftItem: item,
-      strategy,
-      description: describeStrategy(item, strategy),
-      ...repairSql !== void 0 ? { sql: repairSql } : {},
-      automated: strategy !== "MANUAL_SQL",
-      risk: assessRisk(item)
+// src/core/deployment-plan.ts
+function uniqueCommands(commands) {
+  const seen = /* @__PURE__ */ new Set();
+  return commands.filter((item) => {
+    if (seen.has(item.command)) return false;
+    seen.add(item.command);
+    return true;
+  });
+}
+function highestRiskMigration(migrations) {
+  return [...migrations].filter((migration) => migration.riskScore.score > 0).sort((a, b) => b.riskScore.score - a.riskScore.score)[0];
+}
+function actionForCheck(check, state, highestRisk) {
+  const firstPending = state.migrations.find((migration) => migration.status === "pending");
+  switch (check.id) {
+    case "database":
+      return {
+        priority: "blocker",
+        title: state.status.hasDatabaseUrl ? "Restore database connectivity" : "Configure DATABASE_URL",
+        detail: state.status.hasDatabaseUrl ? "PrismaFlow found a database URL, but Prisma cannot reach the database. Check credentials, network access, and the target database process." : "Add a local DATABASE_URL before relying on migration status, drift, or simulation output.",
+        command: "prisma-flow doctor"
+      };
+    case "migration-verification":
+      return {
+        priority: "blocker",
+        title: "Verify migration state",
+        detail: "Prisma CLI returned an unverified or error status. Run doctor diagnostics or check schema/database access.",
+        command: "prisma-flow doctor"
+      };
+    case "drift":
+      return {
+        priority: "blocker",
+        title: "Resolve schema drift before deploy",
+        detail: "The live database does not match the Prisma schema or migration history. Review the drift evidence before applying new migrations.",
+        command: "prisma-flow repair --json",
+        href: "/drift"
+      };
+    case "failed-migrations":
+      return {
+        priority: "blocker",
+        title: "Recover failed migration history",
+        detail: "Failed migrations must be investigated and resolved intentionally before more migrations are applied.",
+        command: "prisma migrate resolve",
+        href: "/migrations"
+      };
+    case "pending-migrations":
+      return {
+        priority: "recommended",
+        title: "Simulate pending migration SQL",
+        detail: firstPending ? `Run a simulation for ${firstPending.name}, then deploy only after the output matches your expectations.` : "Run simulation before applying pending migration SQL to a shared database.",
+        command: firstPending ? `prisma-flow simulate ${firstPending.name} --fail-on-destructive` : "prisma-flow simulate <migration> --fail-on-destructive",
+        href: "/simulate"
+      };
+    case "critical-risks":
+      return {
+        priority: "blocker",
+        title: "Review destructive SQL and rollback limits",
+        detail: highestRisk ? `${highestRisk.name} contains critical-risk SQL. Inspect the statements and rollback plan before approval.` : "At least one migration contains destructive SQL. Inspect the SQL and rollback plan before approval.",
+        command: highestRisk ? `prisma-flow inspect ${highestRisk.name} --rollback --sql` : "prisma-flow report --format markdown",
+        href: "/risks"
+      };
+  }
+}
+function buildActions(state, highestRisk) {
+  const failedChecks = state.status.deploymentReadiness.checks.filter((check) => !check.passed);
+  const actions = failedChecks.map((check) => actionForCheck(check, state, highestRisk));
+  const firstPending = state.migrations.find((migration) => migration.status === "pending");
+  if (firstPending && !actions.some((action) => action.command === "prisma migrate deploy")) {
+    actions.push({
+      priority: "recommended",
+      title: "Deploy after review",
+      detail: "Once drift, failures, and destructive SQL are handled, apply pending migrations with Prisma.",
+      command: "prisma migrate deploy",
+      href: "/migrations"
     });
   }
-  return suggestions;
+  if (actions.length === 0) {
+    actions.push({
+      priority: "recommended",
+      title: "Keep a review artifact",
+      detail: "The project is ready. Save a PrismaFlow report for your pull request or release checklist.",
+      command: "prisma-flow report --format markdown --output prismaflow-report.md"
+    });
+  }
+  return actions;
+}
+function buildCommands(state, highestRisk) {
+  const firstPending = state.migrations.find((migration) => migration.status === "pending");
+  const commands = [
+    {
+      label: "CI gate",
+      command: "prisma-flow check --ci --json",
+      reason: "Fail builds when migrations, drift, or configured risk thresholds are unsafe."
+    },
+    {
+      label: "Review artifact",
+      command: "prisma-flow report --format markdown --output prismaflow-report.md",
+      reason: "Create a human-readable migration review summary for PRs and releases."
+    },
+    {
+      label: "Dashboard",
+      command: "prisma-flow dashboard",
+      reason: "Open the local visual dashboard for drift, timeline, rollback, and simulation review."
+    }
+  ];
+  if (firstPending) {
+    commands.unshift(
+      {
+        label: "Inspect pending migration",
+        command: `prisma-flow inspect ${firstPending.name} --rollback --sql`,
+        reason: "Read generated SQL, risk factors, warnings, and rollback coverage before deploy."
+      },
+      {
+        label: "Simulate pending migration",
+        command: `prisma-flow simulate ${firstPending.name} --fail-on-destructive`,
+        reason: "Catch destructive or failing statements before touching a shared database."
+      }
+    );
+    commands.push({
+      label: "Apply migrations",
+      command: "prisma migrate deploy",
+      reason: "Use Prisma to apply reviewed migration files in production or CI."
+    });
+  }
+  if (state.status.driftDetected) {
+    commands.unshift({
+      label: "Repair drift",
+      command: "prisma-flow repair --json",
+      reason: "Generate recovery suggestions for differences between schema and database."
+    });
+  }
+  if (state.status.migrationsFailed > 0) {
+    commands.unshift({
+      label: "Resolve failed migration",
+      command: "prisma migrate resolve",
+      reason: "Mark failed migration state only after the database has been manually verified."
+    });
+  }
+  if (highestRisk && highestRisk.riskScore.level === "critical") {
+    commands.unshift({
+      label: "Critical-risk inspection",
+      command: `prisma-flow inspect ${highestRisk.name} --rollback --sql`,
+      reason: "Review destructive SQL and rollback limitations before approval."
+    });
+  }
+  return uniqueCommands(commands);
+}
+function summarizeDecision(status) {
+  const failedChecks = status.deploymentReadiness.checks.filter((check) => !check.passed);
+  if (failedChecks.length === 0) {
+    return "Ready: no blocking drift, failed migrations, pending work, or critical migration risks were detected.";
+  }
+  const issueLabels = {
+    database: "database connectivity",
+    "migration-verification": "migration verification",
+    drift: "schema drift",
+    "failed-migrations": "failed migrations",
+    "pending-migrations": "pending migrations",
+    "critical-risks": "critical migration risks"
+  };
+  const failedLabels = failedChecks.map((check) => issueLabels[check.id]).join(", ");
+  if (status.deploymentReadiness.status === "blocked") {
+    return `Blocked: fix ${failedLabels} before deploying.`;
+  }
+  return `Attention needed: review ${failedLabels} before deploying.`;
+}
+function createDeploymentPlanFromState(state) {
+  const pending = state.migrations.filter((migration) => migration.status === "pending");
+  const failed = state.migrations.filter((migration) => migration.status === "failed");
+  const unknown = state.migrations.filter((migration) => migration.status === "unknown");
+  const highestRisk = highestRiskMigration(pending.length > 0 ? pending : state.migrations);
+  const drift = state.drift ?? {
+    status: state.status.driftStatus,
+    detected: state.status.driftDetected,
+    count: state.status.driftCount
+  };
+  return {
+    schemaVersion: "prismaflow-plan/v1",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    decision: state.status.deploymentReadiness.status,
+    score: state.status.deploymentReadiness.score,
+    summary: summarizeDecision(state.status),
+    project: {
+      schemaPath: state.project.schemaPath,
+      migrationsPath: state.project.migrationsPath,
+      ...state.project.provider ? { provider: state.project.provider } : {},
+      ...state.project.prismaVersion ? { prismaVersion: state.project.prismaVersion } : {},
+      ...state.project.packageManager ? { packageManager: state.project.packageManager } : {},
+      hasDatabaseUrl: state.project.databaseUrl.length > 0
+    },
+    checks: state.status.deploymentReadiness.checks,
+    migrations: {
+      total: state.migrations.length,
+      applied: state.migrations.filter((migration) => migration.status === "applied").length,
+      pending: pending.length,
+      failed: failed.length,
+      unknown: unknown.length,
+      verification: state.status.migrationVerification,
+      pendingNames: pending.map((migration) => migration.name),
+      failedNames: failed.map((migration) => migration.name),
+      ...highestRisk ? {
+        highestRisk: {
+          name: highestRisk.name,
+          level: highestRisk.riskScore.level,
+          score: highestRisk.riskScore.score,
+          factors: highestRisk.riskScore.factors
+        }
+      } : {}
+    },
+    drift,
+    actions: buildActions(state, highestRisk),
+    commands: buildCommands(state, highestRisk),
+    valueHighlights: [
+      "Go/no-go deployment decision from the same migration state your CI and dashboard use.",
+      "Risk-ranked SQL review, rollback guidance, and simulation commands before Prisma applies anything.",
+      "Drift, failed migrations, pending work, and destructive statements are turned into concrete next actions."
+    ]
+  };
+}
+async function buildDeploymentPlan(cwd) {
+  const project = await detectPrismaProject(cwd);
+  if (!project) throw new Error("No Prisma project found");
+  const [status, migrations] = await Promise.all([getProjectStatus(cwd), getMigrations(cwd)]);
+  return createDeploymentPlanFromState({
+    project,
+    status,
+    migrations
+  });
 }
+
+// src/server/routes/plan.ts
+var app9 = new Hono9();
+app9.get("/", async (c) => {
+  try {
+    const projectPath = c.get("projectPath");
+    const plan = await buildDeploymentPlan(projectPath);
+    return c.json({ success: true, data: plan });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return c.json({ success: false, error: message }, 500);
+  }
+});
+var plan_default = app9;
+
+// src/server/routes/repair.ts
+import { Hono as Hono10 } from "hono";
+
+// src/core/drift-recovery.ts
 function pickStrategy(item) {
   switch (item.type) {
     case "missing_migration":
-      return "APPLY_MIGRATION";
-    case "extra_column":
-    case "extra_table":
-      return "SQUASH";
     case "modified_migration":
-      return "MANUAL_SQL";
+      return "reconcile_history";
+    case "extra_table":
+    case "extra_column":
+    case "table-missing":
+    case "table-extra":
+    case "column-mismatch":
+      return "manual_migration";
+    case "index-change":
+    case "constraint-change":
+      return "manual_sql";
     default:
-      return "MANUAL_SQL";
+      return "review_only";
   }
 }
 function describeStrategy(item, strategy) {
+  const target = item.migrationName ?? item.identifier ?? "detected change";
   switch (strategy) {
-    case "APPLY_MIGRATION":
-      return `Apply missing migration "${item.migrationName ?? item.identifier}" to the database`;
-    case "SQUASH":
-      return `Create a new migration that incorporates the "${item.identifier}" drift (extra ${item.type.replace("extra_", "")} in DB)`;
-    case "MANUAL_SQL":
-      return `Manually review and apply SQL to reconcile "${item.identifier}" \u2014 automated repair not safe`;
-    case "IGNORE":
-      return `"${item.identifier}" is safe to ignore (documentation-only drift)`;
+    case "reconcile_history":
+      return `Reconcile migration history record for "${target}". Note: this updates the _prisma_migrations table only and does NOT execute migration SQL.`;
+    case "manual_migration":
+      return `Author a new Prisma migration or update schema.prisma to reflect the "${target}" change.`;
+    case "manual_sql":
+      return `Review and apply manual SQL adjustments for "${target}" after verifying database constraints and indexes.`;
     default:
-      return `Review drift for "${item.identifier}"`;
+      return `Manually inspect "${target}" \u2014 automated analysis cannot determine safe resolution.`;
   }
 }
-function generateRepairSql(item, strategy) {
-  if (strategy === "APPLY_MIGRATION" && item.migrationName) {
-    return `-- Run: npx prisma migrate resolve --applied "${item.migrationName}"`;
+function generateGuidanceSql(item, strategy) {
+  if (strategy === "reconcile_history" && item.migrationName) {
+    return `-- Manual history reconciliation only (does NOT run SQL):
+-- npx prisma migrate resolve --applied "${item.migrationName}"`;
   }
-  if (strategy === "SQUASH" && item.type === "extra_table") {
-    return `-- Extra table detected. To squash into schema:
--- 1. Add the model to prisma/schema.prisma
--- 2. Run: npx prisma migrate dev --name squash_${item.identifier}`;
+  if (strategy === "manual_migration" && (item.type === "extra_table" || item.type === "table-extra")) {
+    return `-- Extra table detected. To incorporate into Prisma schema:
+-- 1. Add model to prisma/schema.prisma
+-- 2. Run: npx prisma migrate dev --name sync_${item.identifier ?? "table"}`;
   }
-  if (strategy === "SQUASH" && item.type === "extra_column") {
-    const identifier = item.identifier ?? "unknown.unknown";
-    const [table, column] = identifier.split(".");
-    return `-- Extra column ${column} on ${table}. To squash:
--- 1. Add field to model in prisma/schema.prisma
--- 2. Run: npx prisma migrate dev --name squash_${column}_on_${table}`;
+  if (strategy === "manual_migration" && (item.type === "extra_column" || item.type === "column-mismatch")) {
+    return `-- Schema difference detected on ${item.identifier ?? "column"}.
+-- Update prisma/schema.prisma and generate a migration with: npx prisma migrate dev`;
   }
   if (item.sql) {
-    return `-- Suggested SQL (review carefully before running):
+    return `-- Suggested SQL for operator review (do NOT apply without verification):
 ${item.sql}`;
   }
   return void 0;
 }
 function assessRisk(item) {
-  if (item.type === "modified_migration") return "high";
-  if (item.type === "extra_table") return "medium";
-  if (item.type === "extra_column") return "low";
-  if (item.type === "missing_migration") return "medium";
+  if (item.type === "modified_migration" || item.type === "table-missing") return "high";
+  if (item.type === "extra_table" || item.type === "column-mismatch") return "medium";
+  if (item.type === "extra_column" || item.type === "missing_migration") return "medium";
+  if (item.type === "index-change") return "low";
   return "medium";
 }
-async function applyRepairs(suggestions, schemaPath, cwd) {
-  const results = [];
-  for (const suggestion of suggestions) {
-    if (suggestion.strategy !== "APPLY_MIGRATION") continue;
-    if (!suggestion.driftItem.migrationName) continue;
-    const name = suggestion.driftItem.migrationName;
-    try {
-      await execPrisma(cwd, ["migrate", "resolve", "--applied", name, "--schema", schemaPath], {
-        timeout: 3e4
-      });
-      results.push({ migrationName: name, success: true });
-    } catch (err) {
-      const error = err instanceof Error ? err : new Error(String(err));
-      results.push({
-        migrationName: name,
-        success: false,
-        error: error.message
-      });
-    }
+function generateWarnings(item, strategy) {
+  const warnings = [];
+  if (strategy === "reconcile_history") {
+    warnings.push(
+      "prisma migrate resolve only updates the migration record; it does NOT execute migration SQL statements on the database."
+    );
+  }
+  if (item.type === "table-missing") {
+    warnings.push(
+      "The database is missing a table expected by Prisma schema. Queries may fail immediately."
+    );
+  }
+  if (item.type === "modified_migration") {
+    warnings.push(
+      "Migration file contents differ from what was applied. Manual schema verification required."
+    );
+  }
+  return warnings;
+}
+function generateRepairSuggestions(driftItems, _migrationsDir) {
+  const suggestions = [];
+  for (const item of driftItems) {
+    const strategy = pickStrategy(item);
+    const sql = generateGuidanceSql(item, strategy);
+    const warnings = generateWarnings(item, strategy);
+    suggestions.push({
+      driftItem: item,
+      strategy,
+      description: describeStrategy(item, strategy),
+      ...sql !== void 0 ? { sql } : {},
+      automated: false,
+      risk: assessRisk(item),
+      warnings
+    });
   }
-  return results;
+  return suggestions;
+}
+function buildDriftRepairPlan(driftItems, migrationsDir) {
+  const suggestions = generateRepairSuggestions(driftItems, migrationsDir);
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    driftCount: driftItems.length,
+    suggestions,
+    isMutatingDisabled: true
+  };
 }
 
 // src/server/routes/repair.ts
-var app9 = new Hono9();
-app9.get("/", async (c) => {
+var app10 = new Hono10();
+app10.get("/", async (c) => {
   const projectPath = c.get("projectPath");
   try {
     const project = await detectPrismaProject(projectPath);
@@ -1929,45 +3075,32 @@ app9.get("/", async (c) => {
         502
       );
     }
-    const suggestions = generateRepairSuggestions(driftResult.items, project.migrationsPath);
+    const plan = buildDriftRepairPlan(driftResult.items, project.migrationsPath);
     return c.json({
       success: true,
-      data: { drifted: driftResult.status === "drifted", suggestions }
+      data: { drifted: driftResult.status === "drifted", plan }
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     return c.json({ success: false, error: message }, 500);
   }
 });
-app9.post("/apply", async (c) => {
-  const projectPath = c.get("projectPath");
-  try {
-    const project = await detectPrismaProject(projectPath);
-    if (!project) return c.json({ success: false, error: "No Prisma project found" }, 404);
-    const driftResult = await detectDrift(projectPath);
-    if (driftResult.status === "error") {
-      return c.json(
-        {
-          success: false,
-          error: driftResult.errorMessage ?? "Drift detection failed"
-        },
-        502
-      );
-    }
-    const suggestions = generateRepairSuggestions(driftResult.items, project.migrationsPath);
-    const results = await applyRepairs(suggestions, project.schemaPath, projectPath);
-    return c.json({ success: true, data: results });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return c.json({ success: false, error: message }, 500);
-  }
+app10.post("/apply", async (c) => {
+  return c.json(
+    {
+      success: false,
+      error: "Automatic mutating repair is disabled in PrismaFlow V1. Use `prisma-flow repair` for plan-only recovery guidance.",
+      mutatingDisabled: true
+    },
+    400
+  );
 });
-var repair_default = app9;
+var repair_default = app10;
 
 // src/server/routes/risks.ts
-import { Hono as Hono10 } from "hono";
-var app10 = new Hono10();
-app10.get("/", async (c) => {
+import { Hono as Hono11 } from "hono";
+var app11 = new Hono11();
+app11.get("/", async (c) => {
   const projectPath = c.get("projectPath");
   try {
     const project = await detectPrismaProject(projectPath);
@@ -1986,7 +3119,7 @@ app10.get("/", async (c) => {
     return c.json({ success: false, error: message }, 500);
   }
 });
-app10.get("/:migration", async (c) => {
+app11.get("/:migration", async (c) => {
   const projectPath = c.get("projectPath");
   const migrationQuery = c.req.param("migration");
   try {
@@ -2003,31 +3136,29 @@ app10.get("/:migration", async (c) => {
     return c.json({ success: false, error: message }, 500);
   }
 });
-var risks_default = app10;
+var risks_default = app11;
 
 // src/server/routes/rollback.ts
-import path9 from "path";
-import { Hono as Hono11 } from "hono";
+import path8 from "path";
+import { Hono as Hono12 } from "hono";
 
 // src/core/rollback-generator.ts
-import fs11 from "fs/promises";
-import { RollbackError } from "@prisma-flow/shared";
+import fs10 from "fs/promises";
 
 // src/core/simulator.ts
 import { execFile as execFile3 } from "child_process";
-import fs10 from "fs/promises";
+import fs9 from "fs/promises";
 import os from "os";
-import path8 from "path";
-import { promisify as promisify3 } from "util";
-import { SimulationError } from "@prisma-flow/shared";
-var execAsync2 = promisify3(execFile3);
+import path7 from "path";
+import { promisify as promisify2 } from "util";
+var execAsync2 = promisify2(execFile3);
 var DESTRUCTIVE_PATTERNS = [
   {
     pattern: /drop\s+table/i,
     warning: "Drops a table \u2014 all data will be lost"
   },
   {
-    pattern: /truncate\s+table/i,
+    pattern: /truncate\s+table|truncate\s+\w+/i,
     warning: "Truncates a table \u2014 all rows will be deleted"
   },
   {
@@ -2035,8 +3166,8 @@ var DESTRUCTIVE_PATTERNS = [
     warning: "Drops a column \u2014 data in that column will be lost"
   },
   {
-    pattern: /alter\s+column.*not\s+null/i,
-    warning: "Adds NOT NULL \u2014 will fail if existing rows have NULLs"
+    pattern: /alter\s+column.*not\s+null|alter\s+table.*add\s+column.*not\s+null/i,
+    warning: "Adds NOT NULL constraint \u2014 will fail if existing rows have NULLs"
   },
   { pattern: /delete\s+from/i, warning: "Deletes rows \u2014 data will be lost" },
   {
@@ -2072,7 +3203,8 @@ function estimateRowsAffected(sql) {
   return void 0;
 }
 function splitStatements(sql) {
-  return sql.split(";").map((s) => s.trim()).filter((s) => s.length > 0 && !s.startsWith("--"));
+  const withoutComments = sql.split("\n").filter((line) => !line.trimStart().startsWith("--")).join("\n");
+  return withoutComments.split(";").map((s) => s.trim()).filter((s) => s.length > 0);
 }
 function analyseStatically(migrationName, statements) {
   const parsed = statements.map((sql, index) => {
@@ -2094,9 +3226,9 @@ function analyseStatically(migrationName, statements) {
   const allWarnings = destructive.flatMap((s) => s.warnings);
   return {
     migrationName,
+    verification: "static-analysis",
+    outcome: "unknown",
     statements: parsed,
-    wouldSucceed: true,
-    // static analysis optimistic
     destructiveStatements: destructive.length,
     warnings: allWarnings,
     simulatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -2104,46 +3236,89 @@ function analyseStatically(migrationName, statements) {
   };
 }
 async function simulateSqlite(migrationName, sqlFilePath, dbFilePath) {
-  const tmpDir = await fs10.mkdtemp(path8.join(os.tmpdir(), "prismaflow-sim-"));
-  const shadowDb = path8.join(tmpDir, "shadow.db");
+  const tmpDir = await fs9.mkdtemp(path7.join(os.tmpdir(), "prismaflow-sim-"));
+  const shadowDb = path7.join(tmpDir, "shadow.db");
   try {
-    await fs10.copyFile(dbFilePath, shadowDb);
-    const sql = await fs10.readFile(sqlFilePath, "utf-8");
+    await fs9.copyFile(dbFilePath, shadowDb);
+    const sql = await fs9.readFile(sqlFilePath, "utf-8");
     const statements = splitStatements(sql);
     try {
+      const startTime = Date.now();
       await execAsync2("sqlite3", [shadowDb, sql], { timeout: 3e4 });
-      const staticResult = analyseStatically(migrationName, statements);
-      return { ...staticResult, wouldSucceed: true, mode: "shadow" };
+      const durationMs = Date.now() - startTime;
+      const staticAnalysis = analyseStatically(migrationName, statements);
+      return {
+        ...staticAnalysis,
+        verification: "executed",
+        outcome: "success",
+        mode: "shadow",
+        statements: staticAnalysis.statements.map((stmt) => ({
+          ...stmt,
+          success: true,
+          durationMs: Math.round(durationMs / Math.max(1, statements.length))
+        }))
+      };
     } catch (err) {
       const error = err instanceof Error ? err : new Error(String(err));
-      const staticResult = analyseStatically(migrationName, statements);
+      const staticAnalysis = analyseStatically(migrationName, statements);
+      const errorCode = err.code;
+      if (errorCode === "ENOENT" || error.message.includes("ENOENT") || error.message.includes("not recognized")) {
+        return {
+          ...staticAnalysis,
+          verification: "static-analysis",
+          outcome: "unknown",
+          warnings: [
+            ...staticAnalysis.warnings,
+            "sqlite3 CLI is not installed; static analysis only \u2014 execution not verified."
+          ],
+          mode: "static"
+        };
+      }
       return {
-        ...staticResult,
-        wouldSucceed: false,
+        ...staticAnalysis,
+        verification: "executed",
+        outcome: "failure",
         error: error.message,
         mode: "shadow"
       };
     }
   } catch {
-    const sql = await fs10.readFile(sqlFilePath, "utf-8").catch(() => "");
-    return analyseStatically(migrationName, splitStatements(sql));
+    const sql = await fs9.readFile(sqlFilePath, "utf-8").catch(() => "");
+    const staticAnalysis = analyseStatically(migrationName, splitStatements(sql));
+    return {
+      ...staticAnalysis,
+      warnings: [
+        ...staticAnalysis.warnings,
+        "Shadow database setup failed; static analysis only \u2014 execution not verified."
+      ]
+    };
   } finally {
-    await fs10.rm(tmpDir, { recursive: true, force: true }).catch(() => {
+    await fs9.rm(tmpDir, { recursive: true, force: true }).catch(() => {
     });
   }
 }
-async function simulate(migrationName, sqlFilePath, dbFilePath) {
+async function simulate(migrationName, sqlFilePath, dbFilePath, provider) {
   try {
-    const sql = await fs10.readFile(sqlFilePath, "utf-8");
+    const sql = await fs9.readFile(sqlFilePath, "utf-8");
     const statements = splitStatements(sql);
-    if (dbFilePath && dbFilePath !== ":memory:") {
+    if (provider === "sqlite" && dbFilePath && dbFilePath !== ":memory:") {
       try {
-        await fs10.access(dbFilePath);
+        await fs9.access(dbFilePath);
         return await simulateSqlite(migrationName, sqlFilePath, dbFilePath);
       } catch {
       }
     }
-    return analyseStatically(migrationName, statements);
+    const staticResult = analyseStatically(migrationName, statements);
+    if (provider && provider !== "sqlite") {
+      return {
+        ...staticResult,
+        warnings: [
+          ...staticResult.warnings,
+          `Shadow execution is not configured for provider "${provider}"; static analysis only \u2014 execution not verified.`
+        ]
+      };
+    }
+    return staticResult;
   } catch (err) {
     const error = err instanceof Error ? err : new Error(String(err));
     throw new SimulationError(migrationName, error);
@@ -2242,7 +3417,7 @@ function invertStatement(sql) {
 async function generateRollbackPlan(migrationName, sqlFilePath) {
   let sql;
   try {
-    sql = await fs11.readFile(sqlFilePath, "utf-8");
+    sql = await fs10.readFile(sqlFilePath, "utf-8");
   } catch (err) {
     const error = err instanceof Error ? err : new Error(String(err));
     throw new RollbackError(migrationName, `Cannot read SQL file: ${error.message}`);
@@ -2288,8 +3463,8 @@ ${plan.warnings.map((w) => `--   ! ${w}`).join("\n")}` : null,
 }
 
 // src/server/routes/rollback.ts
-var app11 = new Hono11();
-app11.get("/:migration", async (c) => {
+var app12 = new Hono12();
+app12.get("/:migration", async (c) => {
   const projectPath = c.get("projectPath");
   const migrationQuery = c.req.param("migration");
   try {
@@ -2299,7 +3474,7 @@ app11.get("/:migration", async (c) => {
       (m) => m.name === migrationQuery || m.name.startsWith(migrationQuery)
     );
     if (!match) return c.json({ success: false, error: "Migration not found" }, 404);
-    const sqlFile = path9.join(project.migrationsPath, match.name, "migration.sql");
+    const sqlFile = path8.join(project.migrationsPath, match.name, "migration.sql");
     const plan = await generateRollbackPlan(match.name, sqlFile);
     const format = c.req.query("format");
     if (format === "sql") {
@@ -2314,10 +3489,10 @@ app11.get("/:migration", async (c) => {
     return c.json({ success: false, error: message }, 500);
   }
 });
-var rollback_default = app11;
+var rollback_default = app12;
 
 // src/server/routes/schema.ts
-import { Hono as Hono12 } from "hono";
+import { Hono as Hono13 } from "hono";
 
 // src/core/schema-parser.ts
 async function loadGetDMMF() {
@@ -2342,8 +3517,8 @@ async function parseSchema(cwd) {
 }
 
 // src/server/routes/schema.ts
-var app12 = new Hono12();
-app12.get("/", async (c) => {
+var app13 = new Hono13();
+app13.get("/", async (c) => {
   try {
     const projectPath = c.get("projectPath");
     const schema = await parseSchema(projectPath);
@@ -2353,13 +3528,13 @@ app12.get("/", async (c) => {
     return c.json({ success: false, error: message }, 500);
   }
 });
-var schema_default = app12;
+var schema_default = app13;
 
 // src/server/routes/simulate.ts
-import path10 from "path";
-import { Hono as Hono13 } from "hono";
-var app13 = new Hono13();
-app13.get("/:migration", async (c) => {
+import path9 from "path";
+import { Hono as Hono14 } from "hono";
+var app14 = new Hono14();
+app14.get("/:migration", async (c) => {
   const projectPath = c.get("projectPath");
   const migrationQuery = c.req.param("migration");
   try {
@@ -2369,21 +3544,21 @@ app13.get("/:migration", async (c) => {
       (m) => m.name === migrationQuery || m.name.startsWith(migrationQuery)
     );
     if (!match) return c.json({ success: false, error: "Migration not found" }, 404);
-    const sqlFile = path10.join(project.migrationsPath, match.name, "migration.sql");
-    const dbPath = project.provider === "sqlite" && project.databaseUrl ? project.databaseUrl.replace(/^file:/, "") : void 0;
-    const result = await simulate(match.name, sqlFile, dbPath);
+    const sqlFile = path9.join(project.migrationsPath, match.name, "migration.sql");
+    const dbPath = project.provider === "sqlite" && project.databaseUrl ? resolveSqliteFilePath(project.databaseUrl, project.schemaPath) ?? void 0 : void 0;
+    const result = await simulate(match.name, sqlFile, dbPath, project.provider);
     return c.json({ success: true, data: result });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     return c.json({ success: false, error: message }, 500);
   }
 });
-var simulate_default = app13;
+var simulate_default = app14;
 
 // src/server/routes/status.ts
-import { Hono as Hono14 } from "hono";
-var app14 = new Hono14();
-app14.get("/", async (c) => {
+import { Hono as Hono15 } from "hono";
+var app15 = new Hono15();
+app15.get("/", async (c) => {
   try {
     const projectPath = c.get("projectPath");
     const status = await getProjectStatus(projectPath);
@@ -2393,23 +3568,25 @@ app14.get("/", async (c) => {
     return c.json({ success: false, error: message }, 500);
   }
 });
-var status_default = app14;
+var status_default = app15;
 
 // src/server/index.ts
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = path11.dirname(__filename);
+var __dirname = path10.dirname(__filename);
 function createServer(projectPath) {
-  const app15 = new Hono15();
+  const app16 = new Hono16();
   const token = randomBytes(24).toString("hex");
-  app15.use("*", secureHeaders());
-  app15.use(
+  app16.use("*", secureHeaders());
+  app16.use(
     "*",
     cors({
       origin: (origin) => {
         if (!origin) return null;
         try {
           const url = new URL(origin);
-          if (url.hostname === "localhost" || url.hostname === "127.0.0.1") return origin;
+          if (url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "::1" || url.hostname === "[::1]") {
+            return origin;
+          }
         } catch {
         }
         return null;
@@ -2418,18 +3595,19 @@ function createServer(projectPath) {
       allowHeaders: ["Content-Type", "Authorization"]
     })
   );
-  app15.use("*", async (c, next) => {
+  app16.use("*", async (c, next) => {
     c.set("requestId", randomBytes(8).toString("hex"));
     c.res.headers.set("X-Request-Id", c.get("requestId"));
     await next();
   });
-  app15.use("*", async (c, next) => {
+  app16.use("*", async (c, next) => {
     const started = Date.now();
     await next();
+    const parsedUrl = new URL(c.req.url);
     logger.debug(
       {
         method: c.req.method,
-        path: new URL(c.req.url).pathname,
+        path: parsedUrl.pathname,
         status: c.res.status,
         durationMs: Date.now() - started,
         requestId: c.get("requestId")
@@ -2437,78 +3615,78 @@ function createServer(projectPath) {
       "HTTP request"
     );
   });
-  app15.use("/api/*", async (c, next) => {
+  app16.use("/api/*", async (c, next) => {
     const authHeader = c.req.header("Authorization") ?? "";
     const queryToken = c.req.query("token") ?? "";
     const provided = authHeader.startsWith("Bearer ") ? authHeader.slice(7) : queryToken;
     if (provided !== token) {
-      return c.json({ success: false, error: "Unauthorized" }, 401);
+      return c.json({ success: false, error: "Unauthorized \u2014 valid auth token required" }, 401);
     }
     return next();
   });
-  app15.use("*", async (c, next) => {
+  app16.use("*", async (c, next) => {
     c.set("projectPath", projectPath);
     await next();
   });
-  app15.route("/api/migrations", migrations_default);
-  app15.route("/api/status", status_default);
-  app15.route("/api/schema", schema_default);
-  app15.route("/api/drift", drift_default);
-  app15.route("/api/risks", risks_default);
-  app15.route("/api/rollback", rollback_default);
-  app15.route("/api/simulate", simulate_default);
-  app15.route("/api/repair", repair_default);
-  app15.route("/api/diff", diff_default);
-  app15.route("/api/compare", compare_default);
-  app15.route("/api/git", git_default);
-  app15.route("/api/audit", audit_default);
-  app15.route("/api/config", config_default);
-  app15.route("/api/events", events_default);
-  app15.get("/health", (c) => {
+  app16.route("/api/migrations", migrations_default);
+  app16.route("/api/plan", plan_default);
+  app16.route("/api/status", status_default);
+  app16.route("/api/schema", schema_default);
+  app16.route("/api/drift", drift_default);
+  app16.route("/api/risks", risks_default);
+  app16.route("/api/rollback", rollback_default);
+  app16.route("/api/simulate", simulate_default);
+  app16.route("/api/repair", repair_default);
+  app16.route("/api/diff", diff_default);
+  app16.route("/api/compare", compare_default);
+  app16.route("/api/git", git_default);
+  app16.route("/api/audit", audit_default);
+  app16.route("/api/config", config_default);
+  app16.route("/api/events", events_default);
+  app16.get("/health", (c) => {
     return c.json({
       status: "ok",
       service: "prisma-flow",
-      version: process.env.npm_package_version ?? "0.0.0",
       uptime: process.uptime()
     });
   });
   const candidates = [
-    path11.resolve(__dirname, "../public"),
+    path10.resolve(__dirname, "../public"),
     // dist/public
-    path11.resolve(__dirname, "../../public"),
+    path10.resolve(__dirname, "../../public"),
     // packages/cli/public (source)
-    path11.resolve(__dirname, "../../..", "packages", "cli", "public"),
+    path10.resolve(__dirname, "../../..", "packages", "cli", "public"),
     // monorepo relative
-    path11.resolve(process.cwd(), "public"),
+    path10.resolve(process.cwd(), "public"),
     // cwd public
-    path11.resolve(process.cwd(), "packages", "cli", "public"),
-    path11.resolve(process.cwd(), "..", "packages", "cli", "public")
+    path10.resolve(process.cwd(), "packages", "cli", "public"),
+    path10.resolve(process.cwd(), "..", "packages", "cli", "public")
   ];
   let publicDir = null;
   for (const cand of candidates) {
-    if (fs12.existsSync(cand)) {
+    if (fs11.existsSync(cand)) {
       publicDir = cand;
       break;
     }
   }
   if (!publicDir) {
-    publicDir = path11.resolve(__dirname, "../public");
+    publicDir = path10.resolve(__dirname, "../public");
   }
-  if (!fs12.existsSync(publicDir)) {
+  if (!fs11.existsSync(publicDir)) {
     logger.warn({ publicDir }, "serveStatic: public directory not found");
   }
-  app15.use(
+  app16.use(
     "/*",
     serveStatic({
       root: publicDir,
       rewriteRequestPath: (p) => p === "/" ? "/index.html" : p
     })
   );
-  app15.get("*", async (c) => {
+  app16.get("*", async (c) => {
     try {
-      const indexPath = path11.join(publicDir, "index.html");
-      if (fs12.existsSync(indexPath)) {
-        const content = await fs12.promises.readFile(indexPath, "utf-8");
+      const indexPath = path10.join(publicDir, "index.html");
+      if (fs11.existsSync(indexPath)) {
+        const content = await fs11.promises.readFile(indexPath, "utf-8");
         return c.html(content);
       }
       return c.text("Dashboard not built \u2014 run `npm run build` first", 404);
@@ -2516,11 +3694,20 @@ function createServer(projectPath) {
       return c.text("Error serving dashboard", 500);
     }
   });
-  return { app: app15, token };
+  return { app: app16, token };
+}
+function isLoopbackAddress(host) {
+  const normalized = host.trim().toLowerCase();
+  return normalized === "127.0.0.1" || normalized === "localhost" || normalized === "::1" || normalized === "[::1]" || /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(normalized);
 }
-function startServer(app15, port = 5555) {
-  const server = serve({ fetch: app15.fetch, port }, (info) => {
-    logger.info({ port: info.port }, "PrismaFlow API running");
+function startServer(app16, port = 5555, hostname = process.env.PRISMAFLOW_HOST || "127.0.0.1") {
+  if (!isLoopbackAddress(hostname)) {
+    const errorMsg = `SecurityError: PrismaFlow V1 strictly rejects non-loopback bindings (${hostname}) for database safety. Only loopback addresses (127.0.0.1, localhost, ::1) are allowed.`;
+    logger.error({ hostname }, errorMsg);
+    throw new Error(errorMsg);
+  }
+  const server = serve({ fetch: app16.fetch, port, hostname }, (info) => {
+    logger.info({ port: info.port, hostname }, "PrismaFlow API running on loopback");
   });
   const shutdown = () => {
     logger.info("Shutting down PrismaFlow server...");
@@ -2549,9 +3736,9 @@ function dashboardCommand() {
       }
       const port = options.port ? Number.parseInt(options.port, 10) : config.port ?? 5555;
       const shouldOpen = options.open !== false && config.openBrowser;
-      const { app: app15, token } = createServer(cwd);
+      const { app: app16, token } = createServer(cwd);
       const url = `http://localhost:${port}?token=${token}`;
-      startServer(app15, port);
+      startServer(app16, port);
       console.log();
       console.log(chalk3.bold.cyan(" \u{1F680}  PrismaFlow Dashboard"));
       console.log(chalk3.dim("\u2501".repeat(40)));
@@ -2656,12 +3843,12 @@ function diffCommand() {
 
 // src/commands/doctor.ts
 import { execFile as execFile4 } from "child_process";
-import fs13 from "fs/promises";
-import path12 from "path";
-import { promisify as promisify4 } from "util";
+import fs12 from "fs/promises";
+import path11 from "path";
+import { promisify as promisify3 } from "util";
 import chalk5 from "chalk";
 import { Command as Command5 } from "commander";
-var execFileAsync2 = promisify4(execFile4);
+var execFileAsync = promisify3(execFile4);
 async function runChecks(checks) {
   let passed = 0;
   let failed = 0;
@@ -2730,7 +3917,7 @@ function doctorCommand() {
           label: "prisma schema found",
           run: async () => ({
             ok: project !== null,
-            detail: project ? path12.relative(cwd, project.schemaPath) : "not found"
+            detail: project ? path11.relative(cwd, project.schemaPath) : "not found"
           })
         },
         {
@@ -2745,7 +3932,7 @@ function doctorCommand() {
           run: async () => {
             if (!project) return { ok: false, detail: "no project" };
             try {
-              await fs13.access(project.migrationsPath);
+              await fs12.access(project.migrationsPath);
               return {
                 ok: true,
                 detail: `${project.migrations.length} migration(s)`
@@ -2769,14 +3956,14 @@ function doctorCommand() {
           label: "prismaflow.config.ts present",
           run: async () => {
             const configCandidates = [
-              path12.join(cwd, "prismaflow.config.ts"),
-              path12.join(cwd, "prismaflow.config.js"),
-              path12.join(cwd, "prismaflow.config.mjs")
+              path11.join(cwd, "prismaflow.config.ts"),
+              path11.join(cwd, "prismaflow.config.js"),
+              path11.join(cwd, "prismaflow.config.mjs")
             ];
             for (const c of configCandidates) {
               try {
-                await fs13.access(c);
-                return { ok: true, detail: path12.relative(cwd, c) };
+                await fs12.access(c);
+                return { ok: true, detail: path11.relative(cwd, c) };
               } catch {
               }
             }
@@ -2787,11 +3974,11 @@ function doctorCommand() {
           label: "git repository detected",
           run: async () => {
             try {
-              await execFileAsync2("git", ["rev-parse", "--git-dir"], {
+              await execFileAsync("git", ["rev-parse", "--git-dir"], {
                 cwd,
                 timeout: 5e3
               });
-              const { stdout } = await execFileAsync2(
+              const { stdout } = await execFileAsync(
                 "git",
                 ["rev-parse", "--abbrev-ref", "HEAD"],
                 {
@@ -2814,29 +4001,23 @@ function doctorCommand() {
       merge(
         await runChecks([
           {
-            label: "database reachable",
+            label: "database reachable and verified",
             run: async () => {
-              try {
-                await execPrisma(cwd, ["migrate", "status", "--schema", project.schemaPath], {
-                  timeout: 2e4
-                });
-                return { ok: true, detail: "all migrations applied" };
-              } catch (err) {
-                const error = err;
-                const stderr = error.stderr ?? "";
-                const stdout = error.stdout ?? "";
-                if (stderr.includes("P1001") || stderr.includes("Can't reach database server") || stderr.includes("Connection refused")) {
-                  return {
-                    ok: false,
-                    detail: "database unreachable (P1001)"
-                  };
-                }
-                const pending = stdout.match(/have not yet been applied/i);
+              const adapter = getPrismaAdapter(project.prismaVersion);
+              const res = await adapter.getMigrationStatus(cwd, project.schemaPath);
+              if (res.connected && res.verification === "verified") {
+                const pending = Array.from(res.statusMap.values()).filter(
+                  (s) => s === "pending"
+                ).length;
                 return {
                   ok: true,
-                  detail: pending ? "connected \u2014 pending migrations exist" : "connected"
+                  detail: pending > 0 ? `connected \u2014 ${pending} pending migration(s)` : "connected and verified"
                 };
               }
+              return {
+                ok: false,
+                detail: res.errorMessage || `unverified (${res.errorCode ?? "unknown"})`
+              };
             }
           }
         ])
@@ -2954,8 +4135,8 @@ function historyCommand() {
 }
 
 // src/commands/init.ts
-import fs14 from "fs/promises";
-import path13 from "path";
+import fs13 from "fs/promises";
+import path12 from "path";
 import chalk7 from "chalk";
 import { Command as Command7 } from "commander";
 var CONFIG_TEMPLATE = `import type { PrismaFlowConfig } from 'prisma-flow'
@@ -3008,19 +4189,19 @@ export default config
 function initCommand() {
   return new Command7("init").description("Create a prismaflow.config.ts in the current project").option("-f, --force", "Overwrite existing config file").action(async (options) => {
     const cwd = process.cwd();
-    const dest = path13.join(cwd, "prismaflow.config.ts");
+    const dest = path12.join(cwd, "prismaflow.config.ts");
     try {
-      await fs14.access(dest);
+      await fs13.access(dest);
       if (!options.force) {
         console.log(chalk7.yellow("\u26A0  prismaflow.config.ts already exists."));
         console.log(chalk7.dim("   Use --force to overwrite: prisma-flow init --force"));
         process.exit(0);
       }
-      await fs14.writeFile(dest, CONFIG_TEMPLATE, "utf-8");
+      await fs13.writeFile(dest, CONFIG_TEMPLATE, "utf-8");
       console.log(chalk7.green("\u2714  prismaflow.config.ts overwritten."));
     } catch {
       try {
-        await fs14.writeFile(dest, CONFIG_TEMPLATE, "utf-8");
+        await fs13.writeFile(dest, CONFIG_TEMPLATE, "utf-8");
         console.log(chalk7.green("\u2714  Created prismaflow.config.ts"));
         console.log(chalk7.dim("   Edit it to customise PrismaFlow for your project."));
         console.log();
@@ -3040,8 +4221,8 @@ function initCommand() {
 }
 
 // src/commands/inspect.ts
-import fs15 from "fs/promises";
-import path14 from "path";
+import fs14 from "fs/promises";
+import path13 from "path";
 import chalk8 from "chalk";
 import { Command as Command8 } from "commander";
 function inspectCommand() {
@@ -3064,10 +4245,10 @@ function inspectCommand() {
           );
           process.exit(1);
         }
-        const sqlFile = path14.join(project.migrationsPath, match.name, "migration.sql");
+        const sqlFile = path13.join(project.migrationsPath, match.name, "migration.sql");
         let sql = "";
         try {
-          sql = await fs15.readFile(sqlFile, "utf-8");
+          sql = await fs14.readFile(sqlFile, "utf-8");
         } catch {
           sql = "-- SQL file not found";
         }
@@ -3148,20 +4329,232 @@ function inspectCommand() {
   );
 }
 
-// src/commands/repair.ts
+// src/commands/plan.ts
+import fs15 from "fs/promises";
+import path14 from "path";
 import chalk9 from "chalk";
 import { Command as Command9 } from "commander";
+function normalizeFormat(format, json) {
+  if (json) return "json";
+  if (format === "json" || format === "markdown" || format === "md") {
+    return format === "md" ? "markdown" : format;
+  }
+  return "human";
+}
+function renderMarkdown(plan) {
+  const lines = [
+    "# PrismaFlow Deployment Plan",
+    "",
+    `Generated: ${plan.generatedAt}`,
+    `Decision: ${plan.decision}`,
+    `Score: ${plan.score}/100`,
+    "",
+    plan.summary,
+    "",
+    "## Project",
+    "",
+    `- Schema: ${plan.project.schemaPath}`,
+    `- Migrations: ${plan.project.migrationsPath}`,
+    `- Provider: ${plan.project.provider ?? "unknown"}`,
+    `- Prisma version: ${plan.project.prismaVersion ?? "unknown"}`,
+    `- Package manager: ${plan.project.packageManager ?? "unknown"}`,
+    `- DATABASE_URL detected: ${plan.project.hasDatabaseUrl ? "yes" : "no"}`,
+    "",
+    "## Readiness Checks",
+    "",
+    "| Check | Status | Message |",
+    "| --- | --- | --- |",
+    ...plan.checks.map(
+      (check) => `| ${check.label} | ${check.passed ? "pass" : "fail"} | ${check.message} |`
+    ),
+    "",
+    "## Migration Summary",
+    "",
+    `- Total: ${plan.migrations.total}`,
+    `- Applied: ${plan.migrations.applied}`,
+    `- Pending: ${plan.migrations.pending}`,
+    `- Failed: ${plan.migrations.failed}`,
+    `- Drift: ${plan.drift.detected ? `${plan.drift.count} item(s)` : "none"}`,
+    "",
+    "## Next Actions",
+    "",
+    ...plan.actions.map(
+      (action) => `- **${action.priority}: ${action.title}** \u2014 ${action.detail}${action.command ? `
+  - Command: \`${action.command}\`` : ""}`
+    ),
+    "",
+    "## Useful Commands",
+    "",
+    ...plan.commands.map((command) => `- \`${command.command}\` \u2014 ${command.reason}`),
+    ""
+  ];
+  if (plan.migrations.highestRisk) {
+    lines.splice(
+      lines.indexOf("## Next Actions") - 1,
+      0,
+      "",
+      "## Highest Risk",
+      "",
+      `- Migration: ${plan.migrations.highestRisk.name}`,
+      `- Level: ${plan.migrations.highestRisk.level}`,
+      `- Score: ${plan.migrations.highestRisk.score}/100`
+    );
+  }
+  return `${lines.join("\n")}
+`;
+}
+async function writeOutput(content, outputPath) {
+  if (!outputPath) {
+    process.stdout.write(content);
+    return null;
+  }
+  const resolved = path14.resolve(process.cwd(), outputPath);
+  await fs15.mkdir(path14.dirname(resolved), { recursive: true });
+  await fs15.writeFile(resolved, content, "utf-8");
+  return resolved;
+}
+function actionIcon(priority) {
+  if (priority === "blocker") return chalk9.red("!");
+  if (priority === "recommended") return chalk9.yellow(">");
+  return chalk9.dim("-");
+}
+function decisionColor(decision) {
+  if (decision === "ready") return chalk9.green;
+  if (decision === "attention") return chalk9.yellow;
+  return chalk9.red;
+}
+function renderHuman(plan) {
+  const color = decisionColor(plan.decision);
+  const lines = [
+    "",
+    chalk9.bold.cyan(" PrismaFlow Deployment Plan"),
+    chalk9.dim("\u2501".repeat(60)),
+    `${chalk9.bold("Decision:")} ${color(plan.decision.toUpperCase())}`,
+    `${chalk9.bold("Score:")}    ${color(`${plan.score}/100`)}`,
+    `${chalk9.bold("Summary:")}  ${plan.summary}`,
+    "",
+    chalk9.bold("Project"),
+    `  Schema:     ${chalk9.dim(plan.project.schemaPath)}`,
+    `  Migrations: ${chalk9.dim(plan.project.migrationsPath)}`,
+    `  Provider:   ${chalk9.dim(plan.project.provider ?? "unknown")}`,
+    "",
+    chalk9.bold("Readiness")
+  ];
+  for (const check of plan.checks) {
+    lines.push(
+      `  ${check.passed ? chalk9.green("\u2713") : chalk9.red("\u2717")} ${check.label}: ${chalk9.dim(
+        check.message
+      )}`
+    );
+  }
+  lines.push(
+    "",
+    chalk9.bold("Migrations"),
+    `  ${plan.migrations.applied} applied / ${plan.migrations.pending} pending / ${plan.migrations.failed} failed`
+  );
+  if (plan.migrations.highestRisk) {
+    lines.push(
+      `  Highest risk: ${plan.migrations.highestRisk.name} ${chalk9.dim(
+        `(${plan.migrations.highestRisk.level}, ${plan.migrations.highestRisk.score}/100)`
+      )}`
+    );
+  }
+  lines.push("", chalk9.bold("Next Actions"));
+  for (const action of plan.actions) {
+    lines.push(`  ${actionIcon(action.priority)} ${chalk9.bold(action.title)}`);
+    lines.push(`    ${chalk9.dim(action.detail)}`);
+    if (action.command) lines.push(`    ${chalk9.cyan(action.command)}`);
+  }
+  lines.push("", chalk9.bold("Useful Commands"));
+  for (const command of plan.commands.slice(0, 5)) {
+    lines.push(`  ${chalk9.cyan(command.command)}`);
+    lines.push(`    ${chalk9.dim(command.reason)}`);
+  }
+  lines.push("", chalk9.dim("\u2501".repeat(60)), "");
+  return `${lines.join("\n")}`;
+}
+function exitCodeForPlan(plan, ci) {
+  if (!ci) return 0;
+  if (plan.decision === "blocked") return 2;
+  if (plan.decision === "attention") return 1;
+  return 0;
+}
+function planCommand() {
+  return new Command9("plan").description("Generate an actionable migration deployment plan").option("--format <format>", "Output format: human, json, or markdown", "human").option("--json", "Shortcut for --format json").option("--ci", "Exit non-zero when the plan is attention or blocked").option("-o, --output <path>", "Write JSON or Markdown output to a file").action(
+    async (options) => {
+      const cwd = process.cwd();
+      const format = normalizeFormat(options.format, options.json);
+      try {
+        const plan = await buildDeploymentPlan(cwd);
+        const content = format === "json" ? `${JSON.stringify(plan, null, 2)}
+` : format === "markdown" ? renderMarkdown(plan) : renderHuman(plan);
+        const writtenPath = await writeOutput(content, options.output);
+        if (writtenPath) {
+          process.stdout.write(`${chalk9.green("\u2713 Plan written:")} ${writtenPath}
+`);
+        }
+        await Promise.all([
+          writeAuditEntry(
+            cwd,
+            "deployment.plan",
+            plan.decision === "ready" ? "success" : "warning",
+            {
+              decision: plan.decision,
+              score: plan.score,
+              pending: plan.migrations.pending,
+              failed: plan.migrations.failed,
+              drift: plan.drift.count
+            }
+          ),
+          trackEvent("plan", plan.migrations.total)
+        ]).catch(() => {
+        });
+        process.exit(exitCodeForPlan(plan, options.ci));
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (format === "json") {
+          process.stdout.write(`${JSON.stringify({ error: message }, null, 2)}
+`);
+        } else {
+          process.stderr.write(`${chalk9.red(`\u2716 Plan failed: ${message}`)}
+`);
+        }
+        await writeAuditEntry(cwd, "deployment.plan", "failure", { error: message }).catch(
+          () => {
+          }
+        );
+        process.exit(4);
+      }
+    }
+  );
+}
+
+// src/commands/repair.ts
+import chalk10 from "chalk";
+import { Command as Command10 } from "commander";
 function repairCommand() {
-  return new Command9("repair").description("Detect drift and generate (or apply) repair suggestions").option("--apply", "Auto-apply safe repair steps (APPLY_MIGRATION only)").option("--json", "Output as JSON").action(async (options) => {
+  return new Command10("repair").description("Detect schema drift and generate plan-only recovery guidance").option("--apply", "Disabled in V1: mutating repair is plan-only").option("--json", "Output as JSON").action(async (options) => {
     const cwd = process.cwd();
+    if (options.apply) {
+      const errorMsg = "Automatic mutating repair is disabled in PrismaFlow V1 for database safety. `prisma-flow repair` is strictly plan-only. Please review the recovery plan and execute any verified actions manually.";
+      if (options.json) {
+        process.stdout.write(
+          `${JSON.stringify({ ok: false, error: errorMsg, mutatingDisabled: true })}
+`
+        );
+      } else {
+        console.error(chalk10.red(`\u2716  ${errorMsg}`));
+      }
+      process.exit(1);
+    }
     try {
       const project = await detectPrismaProject(cwd);
       if (!project) {
-        console.error(chalk9.red("\u2716  No Prisma project found."));
+        console.error(chalk10.red("\u2716  No Prisma project found."));
         process.exit(1);
       }
       if (!options.json) {
-        process.stdout.write(chalk9.dim("  Detecting drift...\n"));
+        process.stdout.write(chalk10.dim("  Detecting schema drift...\n"));
       }
       const driftResult = await detectDrift(cwd);
       if (driftResult.status === "error") {
@@ -3171,80 +4564,71 @@ function repairCommand() {
 `
           );
         } else {
-          console.error(chalk9.red(`\u2716  Drift detection failed: ${driftResult.errorMessage}`));
+          console.error(chalk10.red(`\u2716  Drift detection failed: ${driftResult.errorMessage}`));
         }
         process.exit(1);
       }
       if (driftResult.status === "clean" || driftResult.items.length === 0) {
         if (options.json) {
           process.stdout.write(
-            `${JSON.stringify({ ok: true, drifted: false, suggestions: [] })}
+            `${JSON.stringify({ ok: true, drifted: false, plan: buildDriftRepairPlan([]) })}
 `
           );
         } else {
-          console.log(chalk9.green("  \u2714  No drift detected \u2014 database is in sync."));
+          console.log(chalk10.green("  \u2714  No drift detected \u2014 database schema is in sync."));
         }
         process.exit(0);
       }
-      const suggestions = generateRepairSuggestions(driftResult.items, project.migrationsPath);
+      const plan = buildDriftRepairPlan(driftResult.items, project.migrationsPath);
       if (options.json) {
-        process.stdout.write(
-          `${JSON.stringify({ ok: true, drifted: true, suggestions }, null, 2)}
-`
-        );
-        if (options.apply) {
-          const results = await applyRepairs(suggestions, project.schemaPath, cwd);
-          const out = JSON.stringify({ applied: results }, null, 2);
-          process.stdout.write(`${out}
+        process.stdout.write(`${JSON.stringify({ ok: true, drifted: true, plan }, null, 2)}
 `);
-        }
         process.exit(0);
       }
       console.log();
-      console.log(chalk9.bold.cyan(" \u{1F527}  Drift Repair"));
-      console.log(chalk9.dim("\u2501".repeat(50)));
+      console.log(chalk10.bold.cyan(" \u{1F527}  PrismaFlow Drift Recovery Plan (Plan-Only)"));
+      console.log(chalk10.dim("\u2501".repeat(60)));
+      console.log(
+        `  ${chalk10.bold("Drift items found:")} ${chalk10.yellow(driftResult.items.length.toString())}`
+      );
       console.log(
-        `  ${chalk9.bold("Drift items found:")} ${chalk9.yellow(driftResult.items.length.toString())}`
+        chalk10.dim("  All suggestions are advisory for manual review before operator execution.")
       );
       console.log();
-      for (const suggestion of suggestions) {
-        const riskColor = suggestion.risk === "high" ? chalk9.red : suggestion.risk === "medium" ? chalk9.yellow : chalk9.green;
+      for (const suggestion of plan.suggestions) {
+        const riskColor = suggestion.risk === "critical" || suggestion.risk === "high" ? chalk10.red : suggestion.risk === "medium" ? chalk10.yellow : chalk10.green;
         console.log(
           `  ${riskColor("\u25CF")} [${riskColor(suggestion.risk.toUpperCase())}] ${suggestion.description}`
         );
         console.log(
-          `     Strategy: ${chalk9.cyan(suggestion.strategy)} (${suggestion.automated ? chalk9.green("automated") : chalk9.yellow("manual")})`
+          `     Strategy: ${chalk10.cyan(suggestion.strategy)} ${chalk10.dim("(manual operator review)")}`
         );
-        if (suggestion.sql) {
-          console.log(chalk9.dim(`     ${suggestion.sql.split("\n")[0]}`));
+        for (const w of suggestion.warnings) {
+          console.log(`     ${chalk10.yellow("\u26A0")} ${chalk10.dim(w)}`);
         }
-      }
-      if (options.apply) {
-        console.log();
-        console.log(chalk9.bold("  Applying auto-repair steps..."));
-        const results = await applyRepairs(suggestions, project.schemaPath, cwd);
-        for (const r of results) {
-          console.log(
-            `    ${r.success ? chalk9.green("\u2713") : chalk9.red("\u2716")} ${r.migrationName}${r.error ? chalk9.dim(` \u2014 ${r.error}`) : ""}`
-          );
+        if (suggestion.sql) {
+          console.log(chalk10.dim(`     ${suggestion.sql.split("\n")[0]}`));
         }
-      } else {
-        console.log();
-        console.log(chalk9.dim("  To auto-apply safe repairs: prisma-flow repair --apply"));
       }
       console.log();
+      console.log(
+        chalk10.dim(
+          "  Note: PrismaFlow V1 is strictly plan-only. To resolve history records, use `prisma migrate resolve` manually."
+        )
+      );
+      console.log();
       await Promise.all([
         writeAuditEntry(cwd, "drift.repair", "success", {
           items: driftResult.items.length,
-          applied: options.apply
+          planOnly: true
         }),
         trackEvent("repair", driftResult.items.length)
       ]).catch(() => {
       });
-      process.exit(driftResult.items.length > 0 && !options.apply ? 2 : 0);
+      process.exit(driftResult.items.length > 0 ? 2 : 0);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      console.error(chalk9.red(`\u2716  ${message}`));
+      console.error(chalk10.red(`\u2716  ${message}`));
       process.exit(1);
     }
   });
@@ -3253,8 +4637,8 @@ function repairCommand() {
 // src/commands/report.ts
 import fs16 from "fs/promises";
 import path15 from "path";
-import chalk10 from "chalk";
-import { Command as Command10 } from "commander";
+import chalk11 from "chalk";
+import { Command as Command11 } from "commander";
 function formatDate(value) {
   if (!value) return "Not recorded";
   const date = new Date(value);
@@ -3275,11 +4659,11 @@ function buildRecommendations(status, migrations, driftCount) {
   const recommendations = [
     ...readinessActions,
     ...uniqueRecommendations(topRiskFactors),
-    ...driftCount > 0 ? ["Review drift details and reconcile the Prisma schema before deployment."] : []
+    ...driftCount > 0 ? ["Review schema drift details and reconcile the Prisma schema before deployment."] : []
   ];
   return recommendations.length > 0 ? recommendations : ["No blocking issues detected. Keep reviewing generated SQL before production deploys."];
 }
-function renderMarkdown(report) {
+function renderMarkdown2(report) {
   const lines = [
     "# PrismaFlow Report",
     "",
@@ -3297,11 +4681,13 @@ function renderMarkdown(report) {
     "## Summary",
     "",
     `- Database connected: ${report.summary.connected ? "yes" : "no"}`,
+    `- Migration verification: ${report.summary.migrationVerification}`,
     `- Applied migrations: ${report.summary.migrationsApplied}`,
     `- Pending migrations: ${report.summary.migrationsPending}`,
     `- Failed migrations: ${report.summary.migrationsFailed}`,
-    `- Drift: ${report.summary.driftDetected ? `${report.summary.driftCount} item(s)` : "none"}`,
-    `- Risk level: ${report.summary.riskLevel}`,
+    `- Unknown migrations: ${report.summary.migrationsUnknown}`,
+    `- Drift: ${report.summary.driftDetected ? `${report.summary.driftCount} item(s)` : report.summary.driftStatus}`,
+    `- Estimated risk level: ${report.summary.riskLevel} (heuristic)`,
     `- Health score: ${report.summary.healthScore}/100`,
     `- Deployment readiness: ${report.readiness.summary} (${report.readiness.score}/100)`,
     "",
@@ -3315,7 +4701,7 @@ function renderMarkdown(report) {
     "",
     "## Migration Timeline",
     "",
-    "| Migration | Status | Created | Applied | Duration | Risk |",
+    "| Migration | Status | Created | Applied | Duration | Estimated Risk |",
     "| --- | --- | --- | --- | --- | --- |",
     ...report.migrations.map(
       (migration) => `| ${migration.name} | ${migration.status} | ${formatDate(migration.createdAt)} | ${formatDate(
@@ -3327,7 +4713,9 @@ function renderMarkdown(report) {
     ""
   ];
   if (report.drift.items.length === 0) {
-    lines.push("No drift detected.");
+    lines.push(
+      report.drift.status === "clean" ? "No drift detected." : `Drift status: ${report.drift.status}`
+    );
   } else {
     for (const item of report.drift.items) {
       lines.push(`- ${item.type}: ${item.description}`);
@@ -3350,19 +4738,19 @@ async function writeReport(content, outputPath) {
   await fs16.writeFile(resolved, content, "utf-8");
   return resolved;
 }
-function normalizeFormat(format, json) {
+function normalizeFormat2(format, json) {
   if (json) return "json";
   if (format === "md" || format === "markdown") return "markdown";
   return "json";
 }
 function reportCommand() {
-  return new Command10("report").description("Generate a local PrismaFlow report for review or CI artifacts").option("--format <format>", "Output format: json or markdown", "json").option("--json", "Shortcut for --format json").option("-o, --output <path>", "Write the report to a file instead of stdout").action(async (options) => {
+  return new Command11("report").description("Generate a local PrismaFlow report for review or CI artifacts").option("--format <format>", "Output format: json or markdown", "json").option("--json", "Shortcut for --format json").option("-o, --output <path>", "Write the report to a file instead of stdout").action(async (options) => {
     const cwd = process.cwd();
-    const format = normalizeFormat(options.format, options.json);
+    const format = normalizeFormat2(options.format, options.json);
     try {
       const project = await detectPrismaProject(cwd);
       if (!project) {
-        process.stderr.write(`${chalk10.red("\u2716 No Prisma project found.")}
+        process.stderr.write(`${chalk11.red("\u2716 No Prisma project found.")}
 `);
         process.exit(4);
       }
@@ -3392,11 +4780,14 @@ function reportCommand() {
         },
         summary: {
           connected: status.connected,
+          migrationVerification: status.migrationVerification,
           migrationsApplied: status.migrationsApplied,
           migrationsPending: status.migrationsPending,
           migrationsFailed: status.migrationsFailed,
+          migrationsUnknown: status.migrationsUnknown,
           driftDetected: status.driftDetected,
           driftCount: status.driftCount,
+          driftStatus: status.driftStatus,
           riskLevel: status.riskLevel,
           healthScore: status.healthScore
         },
@@ -3416,16 +4807,16 @@ function reportCommand() {
         },
         recommendations: buildRecommendations(status, reportMigrations, drift.items.length)
       };
-      const content = format === "markdown" ? renderMarkdown(report) : `${JSON.stringify(report, null, 2)}
+      const content = format === "markdown" ? renderMarkdown2(report) : `${JSON.stringify(report, null, 2)}
 `;
       const writtenPath = await writeReport(content, options.output);
       if (writtenPath) {
-        process.stdout.write(`${chalk10.green("\u2714 Report written:")} ${writtenPath}
+        process.stdout.write(`${chalk11.green("\u2714 Report written:")} ${writtenPath}
 `);
       }
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      process.stderr.write(`${chalk10.red(`\u2716 Report failed: ${message}`)}
+      process.stderr.write(`${chalk11.red(`\u2716 Report failed: ${message}`)}
 `);
       process.exit(4);
     }
@@ -3434,23 +4825,23 @@ function reportCommand() {
 
 // src/commands/rollback.ts
 import path16 from "path";
-import chalk11 from "chalk";
-import { Command as Command11 } from "commander";
+import chalk12 from "chalk";
+import { Command as Command12 } from "commander";
 function rollbackCommand() {
-  return new Command11("rollback").description("Generate a rollback plan for a migration").argument("<migration>", "Migration name or timestamp prefix").option("--json", "Output as JSON").option("--print-sql", "Print the rollback SQL to stdout").option("--include-manual", "Include manual-only steps in SQL output", true).action(
+  return new Command12("rollback").description("Generate a rollback plan for a migration").argument("<migration>", "Migration name or timestamp prefix").option("--json", "Output as JSON").option("--print-sql", "Print the rollback SQL to stdout").option("--include-manual", "Include manual-only steps in SQL output", true).action(
     async (migrationQuery, options) => {
       const cwd = process.cwd();
       try {
         const project = await detectPrismaProject(cwd);
         if (!project) {
-          console.error(chalk11.red("\u2716  No Prisma project found."));
+          console.error(chalk12.red("\u2716  No Prisma project found."));
           process.exit(1);
         }
         const match = project.migrations.find(
           (m) => m.name === migrationQuery || m.name.startsWith(migrationQuery) || m.timestamp.startsWith(migrationQuery)
         );
         if (!match) {
-          console.error(chalk11.red(`\u2716  Migration "${migrationQuery}" not found.`));
+          console.error(chalk12.red(`\u2716  Migration "${migrationQuery}" not found.`));
           process.exit(1);
         }
         const sqlFile = path16.join(project.migrationsPath, match.name, "migration.sql");
@@ -3468,36 +4859,35 @@ function rollbackCommand() {
         const autoCount = plan.steps.filter((s) => s.automated).length;
         const manualCount = plan.steps.filter((s) => !s.automated).length;
         console.log();
-        console.log(chalk11.bold.cyan(` \u21A9  Rollback Plan: ${match.name}`));
-        console.log(chalk11.dim("\u2501".repeat(60)));
+        console.log(chalk12.bold.cyan(` \u21A9  Rollback Plan: ${match.name}`));
+        console.log(chalk12.dim("\u2501".repeat(60)));
         console.log(
-          `  ${chalk11.bold("Steps:")} ${autoCount} automated, ${manualCount > 0 ? chalk11.yellow(`${manualCount} manual`) : chalk11.green("0 manual")}`
+          `  ${chalk12.bold("Steps:")} ${autoCount} automated, ${manualCount > 0 ? chalk12.yellow(`${manualCount} manual`) : chalk12.green("0 manual")}`
         );
         console.log(
-          `  ${chalk11.bold("Fully automated:")} ${plan.automated ? chalk11.green("Yes") : chalk11.yellow("No \u2014 manual review required")}`
+          `  ${chalk12.bold("Fully automated:")} ${plan.automated ? chalk12.green("Yes") : chalk12.yellow("No \u2014 manual review required")}`
         );
         console.log();
-        for (let i = 0; i < plan.steps.length; i++) {
-          const step = plan.steps[i];
-          const icon = step.automated ? chalk11.green("\u2713") : chalk11.yellow("\u26A0");
-          const label = step.automated ? chalk11.dim("[auto]") : chalk11.yellow("[manual]");
+        for (const [i, step] of plan.steps.entries()) {
+          const icon = step.automated ? chalk12.green("\u2713") : chalk12.yellow("\u26A0");
+          const label = step.automated ? chalk12.dim("[auto]") : chalk12.yellow("[manual]");
           console.log(`  ${icon} Step ${i + 1} ${label}`);
-          console.log(`    ${chalk11.dim("Forward:")}  ${step.forwardSql.slice(0, 60)}`);
-          console.log(`    ${chalk11.dim("Rollback:")} ${step.rollbackSql.slice(0, 60)}`);
+          console.log(`    ${chalk12.dim("Forward:")}  ${step.forwardSql.slice(0, 60)}`);
+          console.log(`    ${chalk12.dim("Rollback:")} ${step.rollbackSql.slice(0, 60)}`);
           if (step.warning) {
-            console.log(`    ${chalk11.yellow("\u26A0")} ${step.warning}`);
+            console.log(`    ${chalk12.yellow("\u26A0")} ${step.warning}`);
           }
         }
         if (plan.warnings.length > 0) {
           console.log();
-          console.log(chalk11.bold("  Warnings:"));
+          console.log(chalk12.bold("  Warnings:"));
           for (const w of plan.warnings) {
-            console.log(`    ${chalk11.yellow("\u26A0")} ${w}`);
+            console.log(`    ${chalk12.yellow("\u26A0")} ${w}`);
           }
         }
         console.log();
-        console.log(chalk11.dim("  To generate rollback SQL:"));
-        console.log(chalk11.dim(`    prisma-flow rollback ${match.name} --print-sql`));
+        console.log(chalk12.dim("  To generate rollback SQL:"));
+        console.log(chalk12.dim(`    prisma-flow rollback ${match.name} --print-sql`));
         console.log();
         await Promise.all([
           writeAuditEntry(cwd, "migration.rollback", "success", {
@@ -3509,7 +4899,7 @@ function rollbackCommand() {
         process.exit(plan.hasManualSteps ? 1 : 0);
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        console.error(chalk11.red(`\u2716  ${message}`));
+        console.error(chalk12.red(`\u2716  ${message}`));
         process.exit(1);
       }
     }
@@ -3518,86 +4908,92 @@ function rollbackCommand() {
 
 // src/commands/simulate.ts
 import path17 from "path";
-import chalk12 from "chalk";
-import { Command as Command12 } from "commander";
+import chalk13 from "chalk";
+import { Command as Command13 } from "commander";
 function simulateCommand() {
-  return new Command12("simulate").description("Dry-run a migration to preview its effect without applying it").argument("<migration>", "Migration name or timestamp prefix").option("--json", "Output as JSON").option("--fail-on-destructive", "Exit with code 2 if destructive statements are found").action(
+  return new Command13("simulate").description("Dry-run a migration or perform static SQL analysis to preview changes").argument("<migration>", "Migration name or timestamp prefix").option("--json", "Output as JSON").option("--fail-on-destructive", "Exit with code 2 if destructive statements are found").action(
     async (migrationQuery, options) => {
       const cwd = process.cwd();
       try {
         const project = await detectPrismaProject(cwd);
         if (!project) {
-          console.error(chalk12.red("\u2716  No Prisma project found."));
+          console.error(chalk13.red("\u2716  No Prisma project found."));
           process.exit(1);
         }
         const match = project.migrations.find(
           (m) => m.name === migrationQuery || m.name.startsWith(migrationQuery) || m.timestamp.startsWith(migrationQuery)
         );
         if (!match) {
-          console.error(chalk12.red(`\u2716  Migration "${migrationQuery}" not found.`));
+          console.error(chalk13.red(`\u2716  Migration "${migrationQuery}" not found.`));
           process.exit(1);
         }
         const sqlFile = path17.join(project.migrationsPath, match.name, "migration.sql");
-        const dbPath = project.provider === "sqlite" && project.databaseUrl ? project.databaseUrl.replace(/^file:/, "") : void 0;
-        const result = await simulate(match.name, sqlFile, dbPath);
+        const dbPath = project.provider === "sqlite" && project.databaseUrl ? resolveSqliteFilePath(project.databaseUrl, project.schemaPath) ?? void 0 : void 0;
+        const result = await simulate(match.name, sqlFile, dbPath, project.provider);
         if (options.json) {
           process.stdout.write(`${JSON.stringify(result, null, 2)}
 `);
           process.exit(0);
         }
         console.log();
-        console.log(chalk12.bold.cyan(` \u{1F52C}  Simulation: ${match.name}`));
-        console.log(chalk12.dim("\u2501".repeat(60)));
-        console.log(`  ${chalk12.bold("Mode:")}   ${result.mode}`);
-        console.log(
-          `  ${chalk12.bold("Result:")} ${result.wouldSucceed ? chalk12.green("Would succeed") : chalk12.red("Would fail")}`
-        );
+        console.log(chalk13.bold.cyan(` \u{1F52C}  Migration Simulation: ${match.name}`));
+        console.log(chalk13.dim("\u2501".repeat(60)));
+        let verificationLabel = chalk13.yellow("Static analysis only \u2014 execution not verified");
+        if (result.verification === "executed") {
+          verificationLabel = result.outcome === "success" ? chalk13.green("Executed successfully in shadow database") : chalk13.red("Executed with failure in shadow database");
+        } else if (result.verification === "not-verified") {
+          verificationLabel = chalk13.dim("Not verified for this provider");
+        }
+        console.log(`  ${chalk13.bold("Verification:")} ${verificationLabel}`);
+        console.log(`  ${chalk13.bold("Outcome:")}      ${result.outcome.toUpperCase()}`);
         console.log(
-          `  ${chalk12.bold("Statements:")} ${result.statements.length} (${result.destructiveStatements} destructive)`
+          `  ${chalk13.bold("Statements:")}   ${result.statements.length} (${result.destructiveStatements} destructive)`
         );
         console.log();
         for (const stmt of result.statements) {
-          const icon = stmt.isDestructive ? chalk12.red("\u26A0") : chalk12.green("\u2713");
-          const typeLabel = chalk12.dim(`[${stmt.type}]`);
+          const icon = stmt.isDestructive ? chalk13.red("\u26A0") : chalk13.green("\u2713");
+          const typeLabel = chalk13.dim(`[${stmt.type}]`);
           const preview = stmt.sql.slice(0, 70).replace(/\n/g, " ");
           console.log(
-            `  ${icon} ${typeLabel} ${preview}${stmt.sql.length > 70 ? chalk12.dim("\u2026") : ""}`
+            `  ${icon} ${typeLabel} ${preview}${stmt.sql.length > 70 ? chalk13.dim("\u2026") : ""}`
           );
           for (const w of stmt.warnings) {
-            console.log(`      ${chalk12.yellow("\u2192")} ${chalk12.yellow(w)}`);
+            console.log(`      ${chalk13.yellow("\u2192")} ${chalk13.yellow(w)}`);
           }
         }
         if (result.warnings.length > 0) {
           console.log();
-          console.log(chalk12.bold("  Warnings:"));
+          console.log(chalk13.bold("  Warnings:"));
           for (const w of result.warnings) {
-            console.log(`    ${chalk12.yellow("\u26A0")} ${w}`);
+            console.log(`    ${chalk13.yellow("\u26A0")} ${w}`);
           }
         }
-        if (!result.wouldSucceed && result.error) {
+        if (result.outcome === "failure" && result.error) {
           console.log();
-          console.log(chalk12.red(`  \u2716  Error: ${result.error}`));
+          console.log(chalk13.red(`  \u2716  Execution Error: ${result.error}`));
         }
         console.log();
         await Promise.all([
           writeAuditEntry(
             cwd,
             "migration.simulate",
-            result.wouldSucceed ? "success" : "warning",
+            result.outcome === "failure" ? "failure" : "success",
             {
               migration: match.name,
+              verification: result.verification,
+              outcome: result.outcome,
               destructive: result.destructiveStatements
             }
           ),
           trackEvent("simulate", result.statements.length)
         ]).catch(() => {
         });
-        if (!result.wouldSucceed) process.exit(1);
+        if (result.outcome === "failure") process.exit(1);
         if (options.failOnDestructive && result.destructiveStatements > 0) process.exit(2);
         process.exit(0);
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        console.error(chalk12.red(`\u2716  ${message}`));
+        console.error(chalk13.red(`\u2716  ${message}`));
         process.exit(1);
       }
     }
@@ -3605,10 +5001,10 @@ function simulateCommand() {
 }
 
 // src/commands/status.ts
-import chalk13 from "chalk";
-import { Command as Command13 } from "commander";
+import chalk14 from "chalk";
+import { Command as Command14 } from "commander";
 function statusCommand() {
-  return new Command13("status").description("Show current migration and database status").option("--json", "Output as JSON").option("--quiet", "Suppress decorative output").action(async (options) => {
+  return new Command14("status").description("Show current migration, drift, and database verification status").option("--json", "Output as JSON").option("--quiet", "Suppress decorative output").action(async (options) => {
     const cwd = process.cwd();
     try {
       const project = await detectPrismaProject(cwd);
@@ -3617,8 +5013,8 @@ function statusCommand() {
           process.stdout.write(`${JSON.stringify({ error: "No Prisma project found" })}
 `);
         } else {
-          console.error(chalk13.red("\u2716  No Prisma schema found in the current directory."));
-          console.error(chalk13.dim("   Run prisma init to create one, then try again."));
+          console.error(chalk14.red("\u2716  No Prisma schema found in the current directory."));
+          console.error(chalk14.dim("   Run prisma init to create one, then try again."));
         }
         process.exit(1);
       }
@@ -3627,35 +5023,39 @@ function statusCommand() {
         process.stdout.write(`${JSON.stringify(status, null, 2)}
 `);
       } else {
-        const bar = chalk13.dim("\u2501".repeat(50));
-        const riskColor = status.riskLevel === "critical" ? chalk13.red : status.riskLevel === "high" ? chalk13.red : status.riskLevel === "medium" ? chalk13.yellow : chalk13.green;
+        const bar = chalk14.dim("\u2501".repeat(50));
+        const riskColor = status.riskLevel === "critical" ? chalk14.red : status.riskLevel === "high" ? chalk14.red : status.riskLevel === "medium" ? chalk14.yellow : chalk14.green;
         if (!options.quiet) console.log();
-        console.log(chalk13.bold.cyan(" \u{1F4CA}  PrismaFlow Status"));
+        console.log(chalk14.bold.cyan(" \u{1F4CA}  PrismaFlow Status"));
         console.log(bar);
         console.log(
-          chalk13.bold(" Schema:       ") + chalk13.dim(status.schemaPath ?? project.schemaPath)
+          chalk14.bold(" Schema:       ") + chalk14.dim(status.schemaPath ?? project.schemaPath)
         );
         if (status.provider) {
-          console.log(chalk13.bold(" Provider:     ") + chalk13.cyan(status.provider));
+          console.log(chalk14.bold(" Provider:     ") + chalk14.cyan(status.provider));
         }
         console.log(
-          chalk13.bold(" Database:     "),
-          status.connected ? chalk13.green("\u2714 Connected") : chalk13.red("\u2716 Disconnected")
+          chalk14.bold(" Database:     "),
+          status.connected ? chalk14.green("\u2714 Connected") : chalk14.red("\u2716 Disconnected")
         );
         console.log(
-          chalk13.bold(" Migrations:   ") + chalk13.green(`${status.migrationsApplied} applied`) + chalk13.dim("  /  ") + (status.migrationsPending > 0 ? chalk13.yellow(`${status.migrationsPending} pending`) : chalk13.dim("0 pending")) + chalk13.dim("  /  ") + (status.migrationsFailed > 0 ? chalk13.red(`${status.migrationsFailed} failed`) : chalk13.dim("0 failed"))
+          chalk14.bold(" Verification: "),
+          status.migrationVerification === "verified" ? chalk14.green("\u2714 Verified") : chalk14.red(`\u2716 ${status.migrationVerification}`)
         );
         console.log(
-          chalk13.bold(" Drift:        "),
-          status.driftDetected ? chalk13.red(
+          chalk14.bold(" Migrations:   ") + chalk14.green(`${status.migrationsApplied} applied`) + chalk14.dim("  /  ") + (status.migrationsPending > 0 ? chalk14.yellow(`${status.migrationsPending} pending`) : chalk14.dim("0 pending")) + chalk14.dim("  /  ") + (status.migrationsFailed > 0 ? chalk14.red(`${status.migrationsFailed} failed`) : chalk14.dim("0 failed")) + (status.migrationsUnknown > 0 ? chalk14.dim("  /  ") + chalk14.red(`${status.migrationsUnknown} unknown`) : "")
+        );
+        console.log(
+          chalk14.bold(" Drift:        "),
+          status.driftDetected ? chalk14.red(
             `\u2716 ${status.driftCount} issue${status.driftCount !== 1 ? "s" : ""} detected`
-          ) : chalk13.green("\u2714 None")
+          ) : status.driftStatus === "not_checked" ? chalk14.yellow("\u26A0 Not checked") : chalk14.green("\u2714 None")
         );
         console.log(
-          chalk13.bold(" Risk Level:   ") + riskColor(chalk13.bold(status.riskLevel.toUpperCase()))
+          chalk14.bold(" Risk Level:   ") + riskColor(chalk14.bold(status.riskLevel.toUpperCase())) + chalk14.dim(" (heuristic)")
         );
         console.log(
-          chalk13.bold(" Health Score: ") + riskColor(chalk13.bold(`${status.healthScore}/100`)) + chalk13.dim(` (${status.deploymentReadiness.summary})`)
+          chalk14.bold(" Health Score: ") + riskColor(chalk14.bold(`${status.healthScore}/100`)) + chalk14.dim(` (${status.deploymentReadiness.summary})`)
         );
         const lastMigration = migrations.filter((m) => m.status === "applied").pop();
         if (lastMigration) {
@@ -3665,27 +5065,37 @@ function statusCommand() {
             day: "numeric"
           });
           console.log(
-            chalk13.bold(" Last Applied: ") + chalk13.dim(`${lastMigration.name} (${date})`)
+            chalk14.bold(" Last Applied: ") + chalk14.dim(`${lastMigration.name} (${date})`)
           );
         }
         console.log(
-          chalk13.bold(" Last Sync:    ") + chalk13.dim(new Date(status.lastSync).toLocaleString())
+          chalk14.bold(" Last Sync:    ") + chalk14.dim(new Date(status.lastSync).toLocaleString())
         );
         console.log(bar);
+        if (!status.connected) {
+          console.log(chalk14.red(" \u2716  Database unreachable \u2014 check DATABASE_URL in .env"));
+        }
+        if (status.migrationVerification !== "verified") {
+          console.log(
+            chalk14.red(
+              ` \u2716  Migration verification: ${status.migrationVerification} \u2014 run prisma-flow doctor`
+            )
+          );
+        }
         if (status.migrationsPending > 0) {
-          console.log(chalk13.yellow(" \u26A0  Pending migrations \u2014 run: prisma migrate deploy"));
+          console.log(chalk14.yellow(" \u26A0  Pending migrations \u2014 run: prisma migrate deploy"));
         }
         if (status.migrationsFailed > 0) {
-          console.log(chalk13.red(" \u2716  Failed migrations \u2014 run: prisma migrate resolve"));
+          console.log(chalk14.red(" \u2716  Failed migrations \u2014 run: prisma migrate resolve"));
         }
         if (status.driftDetected) {
-          console.log(chalk13.red(" \u2716  Schema drift \u2014 review the dashboard Drift page"));
+          console.log(chalk14.red(" \u2716  Schema drift \u2014 review the dashboard Drift page"));
         }
         if (status.deploymentReadiness.status === "ready") {
-          console.log(chalk13.green(" \u2714  Deployment readiness checks passed"));
+          console.log(chalk14.green(" \u2714  Deployment readiness checks passed"));
         } else {
           for (const check of status.deploymentReadiness.checks.filter((item) => !item.passed)) {
-            console.log(chalk13.yellow(` \u26A0  ${check.label}: ${check.message}`));
+            console.log(chalk14.yellow(` \u26A0  ${check.label}: ${check.message}`));
           }
         }
         if (!options.quiet) console.log();
@@ -3707,7 +5117,7 @@ function statusCommand() {
         process.stdout.write(`${JSON.stringify({ error: message })}
 `);
       } else {
-        console.error(chalk13.red(`\u2716  Error: ${message}`));
+        console.error(chalk14.red(`\u2716  Error: ${message}`));
       }
       await writeAuditEntry(cwd, "status.check", "failure", {
         error: message
@@ -3719,12 +5129,21 @@ function statusCommand() {
 }
 
 // src/index.ts
-var program = new Command14();
-program.name("prisma-flow").description("Visual Prisma migration management \u2014 safe, observable, production-ready").version(process.env.npm_package_version ?? "0.1.0");
-program.addCommand(dashboardCommand(), { isDefault: true });
+var require2 = createRequire2(import.meta.url);
+var cliVersion = "0.2.0";
+try {
+  const pkg = require2("../package.json");
+  if (pkg.version) cliVersion = pkg.version;
+} catch {
+  cliVersion = process.env.npm_package_version ?? "0.2.0";
+}
+var program = new Command15();
+program.name("prisma-flow").description("Visual Prisma migration management \u2014 safe, observable, production-ready").version(cliVersion);
+program.addCommand(dashboardCommand());
 program.addCommand(statusCommand());
 program.addCommand(checkCommand());
 program.addCommand(reportCommand());
+program.addCommand(planCommand());
 program.addCommand(initCommand());
 program.addCommand(doctorCommand());
 program.addCommand(inspectCommand());
@@ -3734,4 +5153,10 @@ program.addCommand(rollbackCommand());
 program.addCommand(repairCommand());
 program.addCommand(compareCommand());
 program.addCommand(historyCommand());
+var args = process.argv.slice(2);
+var firstArg = args[0];
+var startsWithDashboardOption = firstArg === "-p" || firstArg === "--port" || firstArg?.startsWith("--port=") || firstArg === "--no-open";
+if (args.length === 0 || startsWithDashboardOption) {
+  process.argv.splice(2, 0, "dashboard");
+}
 program.parse(process.argv);