@happyvertical/smrt-cli 0.40.69 → 0.41.0

package/dist/{commands-U7gYv14z.js → commands-DjgCD-0o.js}

@@ -5,7 +5,7 @@ import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, writeFile
 import * as path from "node:path";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { ObjectRegistry, SchemaComparer, createQualifiedName, generateDDLForEngine, getClassName, isQualifiedName, migratePostgresSystemTimestamps, parseQualifiedName, planPostgresSystemTimestampMigrations } from "@happyvertical/smrt-core";
+import { ObjectRegistry, SchemaComparer, checkLiveSchemaParity, createQualifiedName, ensureDeferredSystemTableCompatibility, generateDDLForEngine, getClassName, isQualifiedName, migratePostgresSystemTimestamps, parseQualifiedName, planPostgresSystemTimestampMigrations } from "@happyvertical/smrt-core";
 import { loadExternalManifestSync } from "@happyvertical/smrt-core/manifest";
 import { access, cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { createLogger } from "@happyvertical/logger";
@@ -409,266 +409,12 @@ async function autoDiscoverAndLoad(projectRoot = process.cwd()) {
 	};
 }
 //#endregion
-//#region src/commands/postgres-timestamp-migration.ts
-/**
-* Fail-closed confirmation shared by PostgreSQL schema preview and migration.
-*
-* A `timestamp without time zone` value cannot establish its own original
-* instant. Callers must therefore make the same explicit UTC provenance
-* confirmation whether they are previewing or applying the conversion.
-*/
-function resolvePostgresTimestampMigration(legacyTimezone) {
-	if (legacyTimezone === void 0) return;
-	if (legacyTimezone !== "UTC") throw new Error("--postgres-timestamp-legacy-timezone must be exactly UTC; refusing to infer the offset of legacy PostgreSQL timestamps");
-	return { legacyTimezone: "UTC" };
-}
-//#endregion
-//#region src/commands/db-diff.ts
-/**
-* db:diff Command
-*
-* Compares manifest schemas to database.
-*/
-var UNSUPPORTED_GENERATE_MESSAGE = "File-backed SMRT migrations are not supported. SMRT schema migrations are manifest-driven; update @smrt object definitions and run smrt db:migrate.";
-var dbDiffCommand = {
-	name: "db:diff",
-	description: "Compare manifest schema to database",
-	aliases: ["diff", "schema-diff"],
-	args: [],
-	options: {
-		generate: {
-			type: "boolean",
-			description: "Unsupported: file-backed migrations are not supported",
-			default: false,
-			short: "g"
-		},
-		name: {
-			type: "string",
-			description: "Unsupported: file-backed migrations are not supported",
-			short: "n"
-		},
-		format: {
-			type: "string",
-			description: "Unsupported: file-backed migrations are not supported",
-			short: "f"
-		},
-		"with-down": {
-			type: "boolean",
-			description: "Unsupported: file-backed migrations are not supported",
-			default: false
-		},
-		output: {
-			type: "string",
-			description: "Unsupported: file-backed migrations are not supported",
-			short: "o"
-		},
-		json: {
-			type: "boolean",
-			description: "Output as JSON",
-			default: false,
-			short: "j"
-		},
-		verbose: {
-			type: "boolean",
-			description: "Show detailed output",
-			default: false,
-			short: "v"
-		},
-		"drop-indexes": {
-			type: "boolean",
-			description: "Include orphan-index drops in the diff (indexes in DB but not in the manifest, excluding *_pkey/*_key implicit-from-constraint indexes). Off by default for safety.",
-			default: false
-		},
-		"postgres-timestamp-legacy-timezone": {
-			type: "string",
-			description: "Confirm that legacy PostgreSQL timestamp-without-time-zone values are UTC wall times before previewing their conversion to timestamptz. Exact value required: UTC; omitted by default."
-		}
-	},
-	handler: async (_args, options) => {
-		let db;
-		try {
-			const postgresTimestampMigration = resolvePostgresTimestampMigration(options["postgres-timestamp-legacy-timezone"]);
-			const unsupportedFileOptions = [
-				"generate",
-				"name",
-				"format",
-				"with-down",
-				"output"
-			].filter((option) => options[option] !== void 0 && options[option] !== false);
-			if (unsupportedFileOptions.length > 0) {
-				const message = `${UNSUPPORTED_GENERATE_MESSAGE} Unsupported option(s): ${unsupportedFileOptions.map((option) => `--${option}`).join(", ")}.`;
-				if (options.json) console.log(JSON.stringify({ error: message }));
-				else console.error(`\n❌ ${message}\n`);
-				process.exitCode = 1;
-				return;
-			}
-			const { getPackageConfig } = await import("@happyvertical/smrt-config");
-			const { DEFAULT_CLI_CONFIG } = await import("./config-BwrFRL8L.js");
-			const config = getPackageConfig("cli", DEFAULT_CLI_CONFIG);
-			if (!config.database?.url || config.database.url === ":memory:") {
-				if (options.json) console.log(JSON.stringify({ error: "Database not configured" }));
-				else {
-					console.error("\n❌ Database configuration required");
-					console.error("\nPlease configure database in smrt.config.js\n");
-				}
-				process.exit(1);
-			}
-			const dbUrl = config.database.url;
-			const dbType = config.database.type || "sqlite";
-			if (!options.json) console.log("\n📊 Schema Diff\n");
-			const { discovered, totalObjects } = await autoDiscoverAndLoad();
-			if (discovered.length === 0) {
-				if (options.json) console.log(JSON.stringify({ error: "No manifests found" }));
-				else {
-					console.error("❌ No SMRT manifests found");
-					console.error("\nRun: smrt test --manifest-only (generates manifest)");
-				}
-				process.exit(1);
-			}
-			if (!options.json) console.log(`✓ Found ${totalObjects} object(s) in ${discovered.length} manifest(s)\n`);
-			const { getDatabase } = await import("@happyvertical/sql");
-			db = await getDatabase({
-				type: dbType,
-				url: dbUrl
-			});
-			const schemaDefinitions = ObjectRegistry.getAllSchemasAsDefinitions();
-			const { SchemaComparer } = await import("@happyvertical/smrt-core/migrations");
-			const diff = await new SchemaComparer(db, {
-				includeDroppedTables: false,
-				includeDroppedColumns: false,
-				includeDroppedIndexes: Boolean(options["drop-indexes"]),
-				postgresTimestampMigration
-			}).compare(schemaDefinitions);
-			if (options.json) {
-				console.log(JSON.stringify({
-					hasChanges: diff.has_changes,
-					addedTables: diff.added_tables.map((t) => t.tableName),
-					droppedTables: diff.dropped_tables,
-					changes: diff.changes
-				}, null, 2));
-				return;
-			}
-			if (!diff.has_changes) {
-				console.log("✅ Database schema is up to date - no changes detected\n");
-				return;
-			}
-			console.log("📋 Changes Detected:\n");
-			if (diff.added_tables.length > 0) {
-				console.log(`  📦 New tables (${diff.added_tables.length}):`);
-				for (const table of diff.added_tables) console.log(`     + ${table.tableName}`);
-				console.log();
-			}
-			const columnChanges = diff.changes.filter((c) => c.type === "add_column");
-			const indexChanges = diff.changes.filter((c) => c.type === "add_index");
-			const indexDrops = diff.changes.filter((c) => c.type === "drop_index");
-			const typeUpgrades = diff.changes.filter((c) => c.type === "type_upgrade");
-			const typeMismatches = diff.changes.filter((c) => c.type === "type_mismatch");
-			const recreateNames = /* @__PURE__ */ new Set();
-			const dropNames = new Set(indexDrops.map((c) => c.name));
-			for (const add of indexChanges) if (add.name && dropNames.has(add.name)) recreateNames.add(add.name);
-			if (columnChanges.length > 0) {
-				console.log(`  📊 New columns (${columnChanges.length}):`);
-				for (const change of columnChanges) console.log(`     + ${change.table}.${change.name}`);
-				console.log();
-			}
-			if (recreateNames.size > 0) {
-				console.log(`  ♻️  Indexes to recreate (${recreateNames.size}):`);
-				for (const name of recreateNames) {
-					const add = indexChanges.find((c) => c.name === name);
-					const cols = add?.index?.columns?.join(", ") ?? "?";
-					const unique = add?.index?.unique ? "UNIQUE " : "";
-					console.log(`     ↻ ${name} → ${unique}(${cols})`);
-				}
-				console.log("     (each recreate is a drop_index followed by add_index)\n");
-			}
-			const orphanDrops = indexDrops.filter((c) => !(c.name && recreateNames.has(c.name)));
-			if (orphanDrops.length > 0) {
-				console.log(`  🗑️  Indexes to drop (${orphanDrops.length}):`);
-				for (const change of orphanDrops) console.log(`     - ${change.name} on ${change.table}`);
-				console.log();
-			}
-			const newIndexes = indexChanges.filter((c) => !(c.name && recreateNames.has(c.name)));
-			if (newIndexes.length > 0) {
-				console.log(`  🗂️  New indexes (${newIndexes.length}):`);
-				for (const change of newIndexes) console.log(`     + ${change.name} on ${change.table}`);
-				console.log();
-			}
-			if (typeUpgrades.length > 0) {
-				console.log(`  🔁 Type upgrades (${typeUpgrades.length}):`);
-				for (const change of typeUpgrades) console.log(`     ⤴ ${change.table}.${change.name}: ${change.mismatch?.actual} → ${change.mismatch?.expected}`);
-				console.log("     (auto-applied by smrt db:migrate)\n");
-			}
-			if (typeMismatches.length > 0) {
-				console.log(`  ⚠️  Type mismatches (${typeMismatches.length}):`);
-				for (const change of typeMismatches) console.log(`     ! ${change.table}.${change.name}: ${change.mismatch?.expected} vs ${change.mismatch?.actual}`);
-				console.log("     (Type changes require manual migration)\n");
-			}
-			console.log("━".repeat(50));
-			console.log("\n💡 Schema migrations are manifest-driven.");
-			console.log("   Update @smrt object definitions, then run smrt db:migrate.\n");
-		} catch (error) {
-			if (options.json) console.log(JSON.stringify({ error: error instanceof Error ? error.message : String(error) }));
-			else {
-				console.error("\n❌ Failed to generate diff:");
-				if (error instanceof Error) console.error(`   ${error.message}`);
-			}
-			process.exitCode = 1;
-			return;
-		} finally {
-			await closeDatabaseConnection(db);
-		}
-	}
-};
-//#endregion
-//#region src/commands/db-generate.ts
-var UNSUPPORTED_MESSAGE = "File-backed SMRT migrations are not supported. SMRT schema migrations are manifest-driven; update @smrt object definitions and run smrt db:migrate.";
-var dbGenerateCommand = {
-	name: "db:generate",
-	description: "[Unsupported] File-backed migrations are not supported",
-	aliases: [
-		"generate",
-		"migration-create",
-		"db:create"
-	],
-	args: ["<name>"],
-	options: {
-		sql: {
-			type: "boolean",
-			description: "Unsupported: file-backed migrations are not supported",
-			default: true
-		},
-		ts: {
-			type: "boolean",
-			description: "Unsupported: file-backed migrations are not supported",
-			default: false
-		},
-		timestamp: {
-			type: "boolean",
-			description: "Unsupported: file-backed migrations are not supported",
-			default: false,
-			short: "t"
-		},
-		output: {
-			type: "string",
-			description: "Unsupported: file-backed migrations are not supported",
-			default: "./migrations",
-			short: "o"
-		},
-		json: {
-			type: "boolean",
-			description: "Output as JSON",
-			default: false,
-			short: "j"
-		}
-	},
-	handler: async (_args, options) => {
-		if (options.json) console.log(JSON.stringify({ error: UNSUPPORTED_MESSAGE }));
-		else console.error(`\n❌ ${UNSUPPORTED_MESSAGE}\n`);
-		process.exitCode = 1;
-	}
-};
-//#endregion
 //#region src/commands/db-migrate-actions.ts
+/** True when a change carries an advisory and no executable statement. */
+function isAdvisoryOnlyChangeLike(change) {
+	if (!change.advisory) return false;
+	return (change.sqlStatements ?? (change.sql ? [change.sql] : [])).length === 0;
+}
 /**
 * Short stable fingerprint of the SQL we'd execute for an action, used
 * to disambiguate index synthetic ids when an index's shape changes
@@ -716,9 +462,27 @@ function classifyTypeUpgradeSql(sql) {
 	if (/no change needed/i.test(trimmed) || /already stores .* as /i.test(trimmed)) return "noop";
 	return "manual";
 }
+/**
+* `alter_column` identities embed the alteration kind and the SQL shape so a
+* column that is tightened, relaxed, and tightened again over its lifetime
+* never reuses an applied tracker id with a different checksum (#2369).
+*/
+function alterColumnMigrationName(tableName, columnName, alteration, action) {
+	const kind = alteration ?? "alter";
+	const fingerprint = sqlShapeFingerprint(action);
+	return fingerprint ? `alter_column_${tableName}_${columnName}_${kind}_${fingerprint}` : `alter_column_${tableName}_${columnName}_${kind}`;
+}
 function getSyntheticMigrationNameForAction(action) {
 	switch (action.type) {
 		case "add_column": return action.column ? `add_column_${action.tableName}_${action.column.name}` : null;
+		case "drop_column": {
+			const columnName = action.columnName ?? action.column?.name;
+			return columnName ? `drop_column_${action.tableName}_${columnName}` : null;
+		}
+		case "alter_column": {
+			const columnName = action.columnName ?? action.column?.name;
+			return columnName ? alterColumnMigrationName(action.tableName, columnName, action.alteration, action) : null;
+		}
 		case "add_index": {
 			if (!action.index) return null;
 			const fingerprint = sqlShapeFingerprint(action);
@@ -740,6 +504,8 @@ function getSyntheticMigrationNameForAction(action) {
 function getSyntheticMigrationNameForChange(change) {
 	switch (change.type) {
 		case "add_column": return change.name ? `add_column_${change.table}_${change.name}` : null;
+		case "drop_column": return change.name ? `drop_column_${change.table}_${change.name}` : null;
+		case "alter_column": return change.name && !isAdvisoryOnlyChangeLike(change) ? alterColumnMigrationName(change.table, change.name, change.alteration, change) : null;
 		case "add_index": {
 			const indexName = change.index?.name ?? change.name;
 			if (!indexName) return null;
@@ -790,14 +556,15 @@ function shouldApplySchemaMigrations(state) {
 	return !state.dryRun;
 }
 function classifyFailedMigration(migrationName, unresolvedSyntheticMigrationNames) {
-	if (!migrationName.startsWith("add_column_") && !migrationName.startsWith("add_index_") && !migrationName.startsWith("drop_index_") && !migrationName.startsWith("type_upgrade_")) return "other";
+	if (!migrationName.startsWith("add_column_") && !migrationName.startsWith("drop_column_") && !migrationName.startsWith("alter_column_") && !migrationName.startsWith("add_index_") && !migrationName.startsWith("drop_index_") && !migrationName.startsWith("type_upgrade_")) return "other";
 	return unresolvedSyntheticMigrationNames.has(migrationName) ? "unresolved" : "superseded";
 }
 function getUnresolvedGeneratedMigrationNames(changes) {
 	const names = /* @__PURE__ */ new Set();
 	for (const change of changes) {
-		if (change.type !== "add_column" && change.type !== "add_index" && change.type !== "drop_index" && change.type !== "type_upgrade") continue;
+		if (change.type !== "add_column" && change.type !== "drop_column" && change.type !== "alter_column" && change.type !== "add_index" && change.type !== "drop_index" && change.type !== "type_upgrade") continue;
 		if (change.type === "type_upgrade" && classifyTypeUpgradeSql(change.sql) === "noop") continue;
+		if (change.type === "alter_column" && isAdvisoryOnlyChangeLike(change)) continue;
 		for (const migrationName of getSyntheticMigrationNamesForChange(change)) names.add(migrationName);
 	}
 	return names;
@@ -831,9 +598,77 @@ function summarizeFailedMigrations(failedMigrations, unresolvedSyntheticMigratio
 function partitionSchemaChanges(changes, getClassForTable) {
 	const migrations = [];
 	const manualInterventions = [];
+	const advisories = [];
 	for (const change of changes) {
 		const className = getClassForTable(change.table);
 		switch (change.type) {
+			case "orphan_column":
+			case "orphan_index":
+				if (!change.name || !change.advisory) continue;
+				advisories.push({
+					type: change.type,
+					tableName: change.table,
+					className,
+					name: change.name,
+					actual: change.mismatch?.actual,
+					advisory: change.advisory
+				});
+				break;
+			case "drop_column":
+				if (!change.name) continue;
+				migrations.push({
+					type: "drop_column",
+					tableName: change.table,
+					className,
+					columnName: change.name,
+					mismatch: change.mismatch ? {
+						column: change.name,
+						expected: change.mismatch.expected,
+						actual: change.mismatch.actual
+					} : void 0,
+					sql: change.sql,
+					...change.sqlStatements ? { sqlStatements: change.sqlStatements } : {}
+				});
+				break;
+			case "alter_column": {
+				if (!change.name) continue;
+				if (isAdvisoryOnlyChangeLike(change) && change.advisory) {
+					advisories.push({
+						type: "alter_column",
+						tableName: change.table,
+						className,
+						name: change.name,
+						alteration: change.alteration,
+						actual: change.mismatch?.actual,
+						advisory: change.advisory
+					});
+					break;
+				}
+				const action = {
+					type: "alter_column",
+					tableName: change.table,
+					className,
+					columnName: change.name,
+					alteration: change.alteration,
+					...change.column ? { column: {
+						name: change.name,
+						type: change.column.type,
+						notNull: change.column.notNull,
+						defaultValue: change.column.defaultValue,
+						unique: change.column.unique
+					} } : {},
+					mismatch: change.mismatch ? {
+						column: change.name,
+						expected: change.mismatch.expected,
+						actual: change.mismatch.actual
+					} : void 0,
+					sql: change.sql,
+					...change.sqlStatements ? { sqlStatements: change.sqlStatements } : {}
+				};
+				if (classifyTypeUpgradeSql(change.sql) === "executable") migrations.push(action);
+				else manualInterventions.push(action);
+				break;
+			}
 			case "add_column": {
 				const col = change.column;
 				if (!change.name || !col) continue;
@@ -880,57 +715,413 @@ function partitionSchemaChanges(changes, getClassForTable) {
 					sql: change.sql,
 					...change.sqlStatements ? { sqlStatements: change.sqlStatements } : {}
 				});
-				break;
-			case "type_mismatch": {
-				const mm = change.mismatch;
-				if (!change.name || !mm) continue;
-				manualInterventions.push({
-					type: "type_mismatch",
-					tableName: change.table,
-					className,
-					mismatch: {
-						column: change.name,
-						expected: mm.expected,
-						actual: mm.actual
-					}
+				break;
+			case "type_mismatch": {
+				const mm = change.mismatch;
+				if (!change.name || !mm) continue;
+				manualInterventions.push({
+					type: "type_mismatch",
+					tableName: change.table,
+					className,
+					mismatch: {
+						column: change.name,
+						expected: mm.expected,
+						actual: mm.actual
+					}
+				});
+				break;
+			}
+			case "type_upgrade": {
+				const mm = change.mismatch;
+				const col = change.column;
+				if (!change.name || !mm || !col) continue;
+				const action = {
+					type: "type_upgrade",
+					tableName: change.table,
+					className,
+					column: {
+						name: change.name,
+						type: col.type,
+						notNull: col.notNull,
+						defaultValue: col.defaultValue,
+						unique: col.unique
+					},
+					mismatch: {
+						column: change.name,
+						expected: mm.expected,
+						actual: mm.actual
+					},
+					sql: change.sql,
+					...change.sqlStatements ? { sqlStatements: change.sqlStatements } : {}
+				};
+				const executionKind = classifyTypeUpgradeSql(change.sql);
+				if (executionKind === "executable") migrations.push(action);
+				else if (executionKind === "manual") manualInterventions.push(action);
+				break;
+			}
+		}
+	}
+	return {
+		migrations,
+		manualInterventions,
+		advisories
+	};
+}
+/**
+* Print report-only schema findings (#2369) in a stable order: warnings
+* first (an orphan NOT NULL column that breaks inserts, a stale unique
+* constraint, a relaxation not opted into), then info, then orphan tables
+* (verbose only — shared databases legitimately hold tables from other
+* apps). Shared by db:migrate and db:diff so both commands report the same
+* findings the same way.
+*/
+function printSchemaAdvisories(advisories, options = {}) {
+	const log = options.log ?? ((line) => console.log(line));
+	const warnings = advisories.filter((a) => a.advisory.severity === "warning");
+	const infos = advisories.filter((a) => a.advisory.severity !== "warning");
+	if (warnings.length > 0) {
+		log("⚠️  Live schema findings that need an operator decision (not applied):\n");
+		for (const item of warnings) {
+			log(`   ${describeAdvisory(item)}`);
+			log(`     ${item.advisory.message}`);
+			for (const suggestion of item.advisory.suggestedSql ?? []) log(`     ↳ ${suggestion}`);
+		}
+		log("");
+	}
+	if (infos.length > 0) {
+		log(`ℹ️  Live schema notes (${infos.length}, not applied):`);
+		for (const item of infos) {
+			log(`   ${describeAdvisory(item)}`);
+			if (options.verbose) {
+				log(`     ${item.advisory.message}`);
+				for (const suggestion of item.advisory.suggestedSql ?? []) log(`     ↳ ${suggestion}`);
+			}
+		}
+		log("");
+	}
+	const orphanTables = options.orphanTables ?? [];
+	if (orphanTables.length > 0 && options.verbose) {
+		log(`ℹ️  Tables in the database that no loaded manifest declares (${orphanTables.length}): ${orphanTables.join(", ")}`);
+		log("   Not dropped; remove them manually if they are stale.\n");
+	}
+}
+function describeAdvisory(item) {
+	switch (item.type) {
+		case "orphan_column": return `${item.tableName}.${item.name}: orphan column${item.actual ? ` (${item.actual})` : ""}`;
+		case "orphan_index": return `${item.tableName}.${item.name}: unique constraint not in manifest${item.actual ? ` (${item.actual})` : ""}`;
+		default: return `${item.tableName}.${item.name}: ${item.alteration ?? "alter_column"}${item.actual ? ` (live: ${item.actual})` : ""}`;
+	}
+}
+//#endregion
+//#region src/commands/postgres-timestamp-migration.ts
+/**
+* Fail-closed confirmation shared by PostgreSQL schema preview and migration.
+*
+* A `timestamp without time zone` value cannot establish its own original
+* instant. Callers must therefore make the same explicit UTC provenance
+* confirmation whether they are previewing or applying the conversion.
+*/
+function resolvePostgresTimestampMigration(legacyTimezone) {
+	if (legacyTimezone === void 0) return;
+	if (legacyTimezone !== "UTC") throw new Error("--postgres-timestamp-legacy-timezone must be exactly UTC; refusing to infer the offset of legacy PostgreSQL timestamps");
+	return { legacyTimezone: "UTC" };
+}
+//#endregion
+//#region src/commands/db-diff.ts
+/**
+* db:diff Command
+*
+* Compares manifest schemas to database.
+*/
+var UNSUPPORTED_GENERATE_MESSAGE = "File-backed SMRT migrations are not supported. SMRT schema migrations are manifest-driven; update @smrt object definitions and run smrt db:migrate.";
+var dbDiffCommand = {
+	name: "db:diff",
+	description: "Compare manifest schema to database",
+	aliases: ["diff", "schema-diff"],
+	args: [],
+	options: {
+		generate: {
+			type: "boolean",
+			description: "Unsupported: file-backed migrations are not supported",
+			default: false,
+			short: "g"
+		},
+		name: {
+			type: "string",
+			description: "Unsupported: file-backed migrations are not supported",
+			short: "n"
+		},
+		format: {
+			type: "string",
+			description: "Unsupported: file-backed migrations are not supported",
+			short: "f"
+		},
+		"with-down": {
+			type: "boolean",
+			description: "Unsupported: file-backed migrations are not supported",
+			default: false
+		},
+		output: {
+			type: "string",
+			description: "Unsupported: file-backed migrations are not supported",
+			short: "o"
+		},
+		json: {
+			type: "boolean",
+			description: "Output as JSON",
+			default: false,
+			short: "j"
+		},
+		verbose: {
+			type: "boolean",
+			description: "Show detailed output",
+			default: false,
+			short: "v"
+		},
+		"drop-indexes": {
+			type: "boolean",
+			description: "Include orphan-index drops in the diff (indexes in DB but not in the manifest, excluding *_pkey/*_key implicit-from-constraint indexes). Off by default for safety.",
+			default: false
+		},
+		"drop-columns": {
+			type: "boolean",
+			description: "Include orphan-column drops in the diff (columns in DB but not in the manifest). Off by default; orphans are always reported.",
+			default: false
+		},
+		"relax-columns": {
+			type: "boolean",
+			description: "Include constraint relaxations in the diff (DROP NOT NULL / DROP DEFAULT on live columns stricter than the manifest, DROP NOT NULL on orphan NOT NULL columns). Off by default; relaxations are always reported.",
+			default: false
+		},
+		"postgres-timestamp-legacy-timezone": {
+			type: "string",
+			description: "Confirm that legacy PostgreSQL timestamp-without-time-zone values are UTC wall times before previewing their conversion to timestamptz. Exact value required: UTC; omitted by default."
+		}
+	},
+	handler: async (_args, options) => {
+		let db;
+		try {
+			const postgresTimestampMigration = resolvePostgresTimestampMigration(options["postgres-timestamp-legacy-timezone"]);
+			const unsupportedFileOptions = [
+				"generate",
+				"name",
+				"format",
+				"with-down",
+				"output"
+			].filter((option) => options[option] !== void 0 && options[option] !== false);
+			if (unsupportedFileOptions.length > 0) {
+				const message = `${UNSUPPORTED_GENERATE_MESSAGE} Unsupported option(s): ${unsupportedFileOptions.map((option) => `--${option}`).join(", ")}.`;
+				if (options.json) console.log(JSON.stringify({ error: message }));
+				else console.error(`\n❌ ${message}\n`);
+				process.exitCode = 1;
+				return;
+			}
+			const { getPackageConfig } = await import("@happyvertical/smrt-config");
+			const { DEFAULT_CLI_CONFIG } = await import("./config-BwrFRL8L.js");
+			const config = getPackageConfig("cli", DEFAULT_CLI_CONFIG);
+			if (!config.database?.url || config.database.url === ":memory:") {
+				if (options.json) console.log(JSON.stringify({ error: "Database not configured" }));
+				else {
+					console.error("\n❌ Database configuration required");
+					console.error("\nPlease configure database in smrt.config.js\n");
+				}
+				process.exit(1);
+			}
+			const dbUrl = config.database.url;
+			const dbType = config.database.type || "sqlite";
+			if (!options.json) console.log("\n📊 Schema Diff\n");
+			const { discovered, totalObjects } = await autoDiscoverAndLoad();
+			if (discovered.length === 0) {
+				if (options.json) console.log(JSON.stringify({ error: "No manifests found" }));
+				else {
+					console.error("❌ No SMRT manifests found");
+					console.error("\nRun: smrt test --manifest-only (generates manifest)");
+				}
+				process.exit(1);
+			}
+			if (!options.json) console.log(`✓ Found ${totalObjects} object(s) in ${discovered.length} manifest(s)\n`);
+			const { getDatabase } = await import("@happyvertical/sql");
+			db = await getDatabase({
+				type: dbType,
+				url: dbUrl
+			});
+			const schemaDefinitions = ObjectRegistry.getAllSchemasAsDefinitions();
+			const { SchemaComparer } = await import("@happyvertical/smrt-core/migrations");
+			const diff = await new SchemaComparer(db, {
+				includeDroppedTables: false,
+				includeDroppedColumns: Boolean(options["drop-columns"]),
+				includeDroppedIndexes: Boolean(options["drop-indexes"]),
+				relaxColumns: Boolean(options["relax-columns"]),
+				postgresTimestampMigration
+			}).compare(schemaDefinitions);
+			if (options.json) {
+				console.log(JSON.stringify({
+					hasChanges: diff.has_changes,
+					addedTables: diff.added_tables.map((t) => t.tableName),
+					droppedTables: diff.dropped_tables,
+					orphanTables: diff.orphan_tables ?? [],
+					changes: diff.changes
+				}, null, 2));
+				return;
+			}
+			const { advisories } = partitionSchemaChanges(diff.changes, (tableName) => tableName);
+			if (!diff.has_changes) {
+				console.log("✅ Database schema is up to date - no changes detected\n");
+				printSchemaAdvisories(advisories, {
+					orphanTables: diff.orphan_tables,
+					verbose: options.verbose
+				});
+				return;
+			}
+			if (diff.changes.filter((c) => !(c.advisory && !c.sql && !c.sqlStatements)).length === 0 && diff.added_tables.length === 0 && diff.dropped_tables.length === 0) {
+				console.log("✅ Database schema is up to date - no migrations needed (see notes below)\n");
+				printSchemaAdvisories(advisories, {
+					orphanTables: diff.orphan_tables,
+					verbose: options.verbose
 				});
-				break;
+				return;
 			}
-			case "type_upgrade": {
-				const mm = change.mismatch;
-				const col = change.column;
-				if (!change.name || !mm || !col) continue;
-				const action = {
-					type: "type_upgrade",
-					tableName: change.table,
-					className,
-					column: {
-						name: change.name,
-						type: col.type,
-						notNull: col.notNull,
-						defaultValue: col.defaultValue,
-						unique: col.unique
-					},
-					mismatch: {
-						column: change.name,
-						expected: mm.expected,
-						actual: mm.actual
-					},
-					sql: change.sql,
-					...change.sqlStatements ? { sqlStatements: change.sqlStatements } : {}
-				};
-				const executionKind = classifyTypeUpgradeSql(change.sql);
-				if (executionKind === "executable") migrations.push(action);
-				else if (executionKind === "manual") manualInterventions.push(action);
-				break;
+			console.log("📋 Changes Detected:\n");
+			if (diff.added_tables.length > 0) {
+				console.log(`  📦 New tables (${diff.added_tables.length}):`);
+				for (const table of diff.added_tables) console.log(`     + ${table.tableName}`);
+				console.log();
+			}
+			const columnChanges = diff.changes.filter((c) => c.type === "add_column");
+			const indexChanges = diff.changes.filter((c) => c.type === "add_index");
+			const indexDrops = diff.changes.filter((c) => c.type === "drop_index");
+			const typeUpgrades = diff.changes.filter((c) => c.type === "type_upgrade");
+			const typeMismatches = diff.changes.filter((c) => c.type === "type_mismatch");
+			const recreateNames = /* @__PURE__ */ new Set();
+			const dropNames = new Set(indexDrops.map((c) => c.name));
+			for (const add of indexChanges) if (add.name && dropNames.has(add.name)) recreateNames.add(add.name);
+			if (columnChanges.length > 0) {
+				console.log(`  📊 New columns (${columnChanges.length}):`);
+				for (const change of columnChanges) console.log(`     + ${change.table}.${change.name}`);
+				console.log();
+			}
+			const columnAlterations = diff.changes.filter((c) => c.type === "alter_column" && (c.sql || c.sqlStatements));
+			const autoAlterations = columnAlterations.filter((c) => classifyTypeUpgradeSql(c.sql) === "executable");
+			const manualAlterations = columnAlterations.filter((c) => classifyTypeUpgradeSql(c.sql) !== "executable");
+			if (autoAlterations.length > 0) {
+				console.log(`  🔧 Column constraint repairs (${autoAlterations.length}):`);
+				for (const change of autoAlterations) console.log(`     ~ ${change.table}.${change.name}: ${change.mismatch?.actual} → ${change.mismatch?.expected} (${change.alteration})`);
+				console.log("     (auto-applied by smrt db:migrate)\n");
 			}
+			if (manualAlterations.length > 0) {
+				console.log(`  ⚠️  Column constraint drift needing a manual step (${manualAlterations.length}):`);
+				for (const change of manualAlterations) {
+					console.log(`     ! ${change.table}.${change.name}: ${change.mismatch?.actual} → ${change.mismatch?.expected} (${change.alteration})`);
+					if (options.verbose && change.sql) console.log(`       ${change.sql.replace(/^--\s*/, "")}`);
+				}
+				console.log();
+			}
+			const columnDrops = diff.changes.filter((c) => c.type === "drop_column");
+			if (columnDrops.length > 0) {
+				console.log(`  🗑️  Columns to drop (${columnDrops.length}, --drop-columns):`);
+				for (const change of columnDrops) console.log(`     - ${change.table}.${change.name}`);
+				console.log();
+			}
+			if (recreateNames.size > 0) {
+				console.log(`  ♻️  Indexes to recreate (${recreateNames.size}):`);
+				for (const name of recreateNames) {
+					const add = indexChanges.find((c) => c.name === name);
+					const cols = add?.index?.columns?.join(", ") ?? "?";
+					const unique = add?.index?.unique ? "UNIQUE " : "";
+					console.log(`     ↻ ${name} → ${unique}(${cols})`);
+				}
+				console.log("     (each recreate is a drop_index followed by add_index)\n");
+			}
+			const orphanDrops = indexDrops.filter((c) => !(c.name && recreateNames.has(c.name)));
+			if (orphanDrops.length > 0) {
+				console.log(`  🗑️  Indexes to drop (${orphanDrops.length}):`);
+				for (const change of orphanDrops) console.log(`     - ${change.name} on ${change.table}`);
+				console.log();
+			}
+			const newIndexes = indexChanges.filter((c) => !(c.name && recreateNames.has(c.name)));
+			if (newIndexes.length > 0) {
+				console.log(`  🗂️  New indexes (${newIndexes.length}):`);
+				for (const change of newIndexes) console.log(`     + ${change.name} on ${change.table}`);
+				console.log();
+			}
+			if (typeUpgrades.length > 0) {
+				console.log(`  🔁 Type upgrades (${typeUpgrades.length}):`);
+				for (const change of typeUpgrades) console.log(`     ⤴ ${change.table}.${change.name}: ${change.mismatch?.actual} → ${change.mismatch?.expected}`);
+				console.log("     (auto-applied by smrt db:migrate)\n");
+			}
+			if (typeMismatches.length > 0) {
+				console.log(`  ⚠️  Type mismatches (${typeMismatches.length}):`);
+				for (const change of typeMismatches) console.log(`     ! ${change.table}.${change.name}: ${change.mismatch?.expected} vs ${change.mismatch?.actual}`);
+				console.log("     (Type changes require manual migration)\n");
+			}
+			printSchemaAdvisories(advisories, {
+				orphanTables: diff.orphan_tables,
+				verbose: options.verbose
+			});
+			console.log("━".repeat(50));
+			console.log("\n💡 Schema migrations are manifest-driven.");
+			console.log("   Update @smrt object definitions, then run smrt db:migrate.\n");
+		} catch (error) {
+			if (options.json) console.log(JSON.stringify({ error: error instanceof Error ? error.message : String(error) }));
+			else {
+				console.error("\n❌ Failed to generate diff:");
+				if (error instanceof Error) console.error(`   ${error.message}`);
+			}
+			process.exitCode = 1;
+			return;
+		} finally {
+			await closeDatabaseConnection(db);
 		}
 	}
-	return {
-		migrations,
-		manualInterventions
-	};
-}
+};
+//#endregion
+//#region src/commands/db-generate.ts
+var UNSUPPORTED_MESSAGE = "File-backed SMRT migrations are not supported. SMRT schema migrations are manifest-driven; update @smrt object definitions and run smrt db:migrate.";
+var dbGenerateCommand = {
+	name: "db:generate",
+	description: "[Unsupported] File-backed migrations are not supported",
+	aliases: [
+		"generate",
+		"migration-create",
+		"db:create"
+	],
+	args: ["<name>"],
+	options: {
+		sql: {
+			type: "boolean",
+			description: "Unsupported: file-backed migrations are not supported",
+			default: true
+		},
+		ts: {
+			type: "boolean",
+			description: "Unsupported: file-backed migrations are not supported",
+			default: false
+		},
+		timestamp: {
+			type: "boolean",
+			description: "Unsupported: file-backed migrations are not supported",
+			default: false,
+			short: "t"
+		},
+		output: {
+			type: "string",
+			description: "Unsupported: file-backed migrations are not supported",
+			default: "./migrations",
+			short: "o"
+		},
+		json: {
+			type: "boolean",
+			description: "Output as JSON",
+			default: false,
+			short: "j"
+		}
+	},
+	handler: async (_args, options) => {
+		if (options.json) console.log(JSON.stringify({ error: UNSUPPORTED_MESSAGE }));
+		else console.error(`\n❌ ${UNSUPPORTED_MESSAGE}\n`);
+		process.exitCode = 1;
+	}
+};
 //#endregion
 //#region src/commands/migration-failure-analysis.ts
 function getActionableGeneratedMigrationNames(change) {
@@ -946,6 +1137,8 @@ function getActionableFailedMigrationNames(diff) {
 }
 function classifyKind(name) {
 	if (name.startsWith("add_column_")) return "add_column";
+	if (name.startsWith("drop_column_")) return "drop_column";
+	if (name.startsWith("alter_column_")) return "alter_column";
 	if (name.startsWith("add_index_")) return "add_index";
 	if (name.startsWith("type_upgrade_")) return "type_upgrade";
 	return "other";
@@ -1157,60 +1350,305 @@ var dbHistoryCommand = {
 				}
 				console.log();
 			}
-			const completed = annotatedHistory.filter((m) => m.status === "completed").length;
-			const failed = annotatedHistory.filter((m) => m.status === "failed").length;
-			const failedUnresolved = annotatedHistory.filter((m) => m.classification === "unresolved").length;
-			const failedSuperseded = annotatedHistory.filter((m) => m.classification === "superseded").length;
-			const failedOther = annotatedHistory.filter((m) => m.classification === "other").length;
-			const rolledBack = annotatedHistory.filter((m) => m.status === "rolled_back").length;
-			const actionRequired = failedAssessments.filter((item) => item.resolution === "action_required").length;
-			const superseded = failedAssessments.filter((item) => item.resolution === "superseded").length;
-			const manualReview = failedAssessments.filter((item) => item.resolution === "manual_review").length;
-			console.log("━".repeat(50));
-			console.log(`Summary: ${completed} completed, ${failed} failed (${failedUnresolved} unresolved, ${failedSuperseded} superseded, ${failedOther} other), ${rolledBack} rolled back`);
-			if (failed > 0) console.log(`         ${actionRequired} failed still require action, ${superseded} are superseded history, ${manualReview} need manual review`);
-			console.log();
-			console.log("💡 Commands:");
-			console.log("   smrt db:status     - Current migration status");
-			console.log("   smrt db:rollback   - Rollback migrations");
-			console.log();
-		} catch (error) {
-			if (options.json) console.log(JSON.stringify({ error: error instanceof Error ? error.message : String(error) }));
+			const completed = annotatedHistory.filter((m) => m.status === "completed").length;
+			const failed = annotatedHistory.filter((m) => m.status === "failed").length;
+			const failedUnresolved = annotatedHistory.filter((m) => m.classification === "unresolved").length;
+			const failedSuperseded = annotatedHistory.filter((m) => m.classification === "superseded").length;
+			const failedOther = annotatedHistory.filter((m) => m.classification === "other").length;
+			const rolledBack = annotatedHistory.filter((m) => m.status === "rolled_back").length;
+			const actionRequired = failedAssessments.filter((item) => item.resolution === "action_required").length;
+			const superseded = failedAssessments.filter((item) => item.resolution === "superseded").length;
+			const manualReview = failedAssessments.filter((item) => item.resolution === "manual_review").length;
+			console.log("━".repeat(50));
+			console.log(`Summary: ${completed} completed, ${failed} failed (${failedUnresolved} unresolved, ${failedSuperseded} superseded, ${failedOther} other), ${rolledBack} rolled back`);
+			if (failed > 0) console.log(`         ${actionRequired} failed still require action, ${superseded} are superseded history, ${manualReview} need manual review`);
+			console.log();
+			console.log("💡 Commands:");
+			console.log("   smrt db:status     - Current migration status");
+			console.log("   smrt db:rollback   - Rollback migrations");
+			console.log();
+		} catch (error) {
+			if (options.json) console.log(JSON.stringify({ error: error instanceof Error ? error.message : String(error) }));
+			else {
+				console.error("\n❌ Failed to get migration history:");
+				if (error instanceof Error) console.error(`   ${error.message}`);
+			}
+			process.exitCode = 1;
+			return;
+		} finally {
+			await closeDatabaseConnection(db);
+		}
+	}
+};
+/**
+* Get status icon for migration status
+*/
+function getStatusIcon(status) {
+	switch (status) {
+		case "completed": return "✓";
+		case "failed": return "✗";
+		case "rolled_back": return "↩";
+		case "running": return "⟳";
+		case "pending": return "○";
+		default: return "?";
+	}
+}
+/**
+* Format date/time for display
+*/
+function formatDateTime(date) {
+	return date.toISOString().replace("T", " ").substring(0, 19);
+}
+//#endregion
+//#region src/commands/db-prune.ts
+/**
+* Packages that contribute retention tasks by registering them on import.
+*
+* `db:prune` runs in the CLI's own process, so a task only reaches the sweep
+* if this process actually loaded the package that registers it. These are
+* imported optionally — a project that does not depend on jobs or users simply
+* has no jobs or users tasks, which is the correct outcome, not an error.
+*/
+var RETENTION_TASK_PACKAGES = ["@happyvertical/smrt-jobs", "@happyvertical/smrt-users"];
+/**
+* Load every installed package that contributes retention tasks.
+*
+* A rejected import is always treated as "not installed" — this function
+* cannot reliably tell a genuine module-resolution miss apart from a package
+* that resolved but threw during its own top-level evaluation (error shapes
+* differ across bundlers and runtimes, and `importPackage` is caller-supplied
+* for exactly that flexibility). It still logs the message on `stderr`
+* rather than swallowing it outright, so an operator can tell "this project
+* doesn't depend on jobs/users" apart from "smrt-jobs is installed but broke
+* on import" without the sweep itself needing to fail over an optional
+* dependency.
+*
+* @returns The specifiers that loaded, in declaration order.
+*/
+async function loadRetentionTaskPackages(importPackage) {
+	const loaded = [];
+	for (const specifier of RETENTION_TASK_PACKAGES) try {
+		await importPackage(specifier);
+		loaded.push(specifier);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		console.warn(`⚠️  Could not load ${specifier} (${message}). Treating its retention tasks as not contributed — if the package is installed, this may be a real import failure rather than a missing dependency.`);
+	}
+	return loaded;
+}
+/**
+* Merge command-line overrides onto the configured retention policy.
+*
+* `--skip` names tasks, not tables, so it covers both the built-in tables and
+* anything a package registered — the same names `db:prune --json` reports.
+*/
+function buildPrunePolicy(configured, options) {
+	const policy = { ...configured ?? {} };
+	policy.dryRun = options["dry-run"] || (configured?.dryRun ?? false);
+	if (options["changes-days"] !== void 0) policy.changes = {
+		...policy.changes === false ? {} : policy.changes ?? {},
+		maxAgeDays: options["changes-days"]
+	};
+	if (options["usage-days"] !== void 0) policy.aiUsage = {
+		...policy.aiUsage === false ? {} : policy.aiUsage ?? {},
+		maxAgeDays: options["usage-days"]
+	};
+	if (options["dispatch-days"] !== void 0) policy.dispatch = {
+		...policy.dispatch === false ? {} : policy.dispatch ?? {},
+		completedOlderThanDays: options["dispatch-days"]
+	};
+	const skipped = (options.skip ?? "").split(",").map((name) => name.trim()).filter((name) => name.length > 0);
+	for (const name of skipped) switch (name) {
+		case "changes":
+			policy.changes = false;
+			break;
+		case "ai-usage":
+			policy.aiUsage = false;
+			break;
+		case "contexts":
+			policy.contexts = false;
+			break;
+		case "dispatch":
+			policy.dispatch = false;
+			break;
+		default: policy.tasks = {
+			...policy.tasks ?? {},
+			[name]: false
+		};
+	}
+	return policy;
+}
+/** Render a completed sweep as an operator-readable table. */
+function formatSweepResult(result) {
+	const lines = [];
+	const verb = result.dryRun ? "would prune" : "pruned";
+	for (const task of result.tasks) {
+		const status = task.error ? `error: ${task.error}` : task.skipped ? task.skipped : `${verb} ${task.pruned}`;
+		const detail = task.details ? ` (${Object.entries(task.details).map(([key, value]) => `${key}=${value}`).join(", ")})` : "";
+		lines.push(`  ${task.task.padEnd(24)}${status}${detail}`);
+	}
+	lines.push("");
+	lines.push(`  ${"total".padEnd(24)}${verb} ${result.pruned} row(s) in ${result.durationMs}ms`);
+	return lines.join("\n");
+}
+/**
+* Names passed to `--skip` that no task in the completed sweep answered to.
+*
+* A typo and a package that was never installed look identical on the command
+* line, so the command says which names it did not recognize rather than
+* silently doing less than the operator asked for.
+*/
+function unmatchedSkipNames(skip, result) {
+	const known = new Set(result.tasks.map((task) => task.task));
+	return (skip ?? "").split(",").map((name) => name.trim()).filter((name) => name.length > 0 && !known.has(name));
+}
+var dbPruneCommand = {
+	name: "db:prune",
+	description: "Prune framework-owned system tables to their retention windows",
+	args: [],
+	options: {
+		"dry-run": {
+			type: "boolean",
+			description: "Report what would be deleted without deleting it",
+			default: false
+		},
+		json: {
+			type: "boolean",
+			description: "Output as JSON (for CI/cron integration)",
+			default: false,
+			short: "j"
+		},
+		"changes-days": {
+			type: "number",
+			description: "Retention window for _smrt_changes, in days"
+		},
+		"usage-days": {
+			type: "number",
+			description: "Retention window for _smrt_ai_usage, in days"
+		},
+		"dispatch-days": {
+			type: "number",
+			description: "Retention window for completed _smrt_dispatch rows, in days"
+		},
+		skip: {
+			type: "string",
+			description: "Comma-separated task names to skip (changes, ai-usage, contexts, dispatch, …)"
+		}
+	},
+	handler: async (_args, options) => {
+		let db;
+		try {
+			const { getPackageConfig } = await import("@happyvertical/smrt-config");
+			const { DEFAULT_CLI_CONFIG } = await import("./config-BwrFRL8L.js");
+			const config = getPackageConfig("cli", DEFAULT_CLI_CONFIG);
+			if (!config.database?.url) {
+				const message = "Database not configured. Set database.url in smrt.config.ts.";
+				if (options.json) console.log(JSON.stringify({ error: message }));
+				else console.error(`\n❌ ${message}\n`);
+				process.exitCode = 1;
+				return;
+			}
+			const dbUrl = config.database.url;
+			const dbType = config.database.type || "sqlite";
+			const { getDatabase } = await import("@happyvertical/sql");
+			db = await getDatabase({
+				type: dbType,
+				url: dbUrl
+			});
+			const { config: smrtConfig, importOptionalDependency, runRetentionSweep } = await import("@happyvertical/smrt-core");
+			const loaded = await loadRetentionTaskPackages((specifier) => importOptionalDependency(specifier, "Install it in the project to include its retention tasks."));
+			const policy = buildPrunePolicy(smrtConfig.toJSON().retention, options);
+			const result = await runRetentionSweep(db, policy);
+			const unmatched = unmatchedSkipNames(options.skip, result);
+			if (options.json) console.log(JSON.stringify({
+				...result,
+				contributors: loaded,
+				unmatched
+			}, null, 2));
 			else {
-				console.error("\n❌ Failed to get migration history:");
-				if (error instanceof Error) console.error(`   ${error.message}`);
+				console.log(`\n🧹 Retention sweep${result.dryRun ? " (dry run)" : ""}\n`);
+				console.log(`Database: ${formatDatabaseDisplayUrl(dbType, dbUrl)}\n`);
+				console.log(formatSweepResult(result));
+				console.log();
+				if (unmatched.length > 0) console.warn(`⚠️  --skip named no known task: ${unmatched.join(", ")}. Check the spelling, or the package that registers it may not be installed.
+`);
 			}
+			if (result.failed) process.exitCode = 1;
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			if (options.json) console.log(JSON.stringify({ error: message }));
+			else console.error(`\n❌ Retention sweep failed: ${message}\n`);
 			process.exitCode = 1;
-			return;
 		} finally {
 			await closeDatabaseConnection(db);
 		}
 	}
 };
+//#endregion
+//#region src/commands/db-rollback.ts
 /**
-* Get status icon for migration status
+* Name prefix of the only migration class `db:migrate` records a DOWN script
+* for (`utilities.ts`, `diff.added_tables` loop:
+* `down: ['DROP TABLE IF EXISTS "<table>"']`). Keep the two in step — this
+* command reconstructs that exact statement from the recorded migration name.
 */
-function getStatusIcon(status) {
-	switch (status) {
-		case "completed": return "✓";
-		case "failed": return "✗";
-		case "rolled_back": return "↩";
-		case "running": return "⟳";
-		case "pending": return "○";
-		default: return "?";
-	}
-}
+var CREATE_TABLE_MIGRATION_PREFIX = "create_table_";
 /**
-* Format date/time for display
+* The suffix of a `create_table_*` row must be a bare SQL identifier before it
+* is interpolated into the reconstructed `DROP TABLE`. Quotes, whitespace,
+* semicolons and dots all fail closed (the migration is refused) rather than
+* producing a statement that drops something other than the recorded table.
+*
+* Deliberately not lowercase-only: `classnameToTablename` yields snake_case,
+* but `@smrt({ tableName })` passes a consumer-supplied name through verbatim,
+* so a legitimately reversible table can carry capitals. This is a shape and
+* injection guard, not a naming-convention check.
 */
-function formatDateTime(date) {
-	return date.toISOString().replace("T", " ").substring(0, 19);
+var SAFE_TABLE_NAME_RE = /^[A-Za-z_][A-Za-z0-9_$]*$/;
+/** Human-readable refusal headline, printed above the per-migration reasons. */
+var REFUSAL_HEADLINE = "Refusing to roll back: no DOWN script is available for the selected migration(s).";
+/** Single-line refusal used for the JSON payload. */
+var REFUSAL_ERROR = `${REFUSAL_HEADLINE} Nothing was changed.`;
+/** Why the refusal happened and the two ways forward, printed with it. */
+var REFUSAL_GUIDANCE = [
+	"SMRT schema migrations are diff-driven: db:migrate stores no SQL in _smrt_schema_migrations and records a DOWN script only for create_table_<table> migrations.",
+	"Revert these by updating the @smrt object definitions and running smrt db:migrate, or by reverting the schema by hand.",
+	"Re-run with --mark-only to mark them rolled_back in the tracking table WITHOUT changing the schema (record-only)."
+];
+/**
+* Reconstruct the DOWN script for an applied migration, or explain why it
+* cannot be reconstructed.
+*
+* Recoverable only for `create_table_<table>` rows recorded as reversible: the
+* DOWN `db:migrate` attached to them is the deterministic
+* `DROP TABLE IF EXISTS "<table>"`. A row recorded reversible under any other
+* name came from a caller-supplied `MigrationDefinition` whose SQL was never
+* persisted, so it is refused rather than guessed at.
+*
+* Exported for unit testing.
+*/
+function recoverDownStatements(migration) {
+	if (!migration.name.startsWith(CREATE_TABLE_MIGRATION_PREFIX)) return {
+		recoverable: false,
+		reason: migration.is_reversible ? "recorded as reversible, but its DOWN SQL is not stored in _smrt_schema_migrations and cannot be reconstructed" : "was applied without a DOWN script"
+	};
+	if (!migration.is_reversible) return {
+		recoverable: false,
+		reason: "is recorded as not reversible"
+	};
+	const tableName = migration.name.slice(13);
+	if (!SAFE_TABLE_NAME_RE.test(tableName)) return {
+		recoverable: false,
+		reason: `names table "${tableName}", which is not a plain identifier db:migrate would have generated`
+	};
+	return {
+		recoverable: true,
+		statements: [`DROP TABLE IF EXISTS "${tableName}"`]
+	};
 }
-//#endregion
-//#region src/commands/db-rollback.ts
 var dbRollbackCommand = {
 	name: "db:rollback",
-	description: "Rollback applied migrations",
+	description: "Rollback applied migrations by executing their DOWN script",
 	aliases: ["rollback", "migration-rollback"],
 	args: [],
 	options: {
@@ -1230,6 +1668,12 @@ var dbRollbackCommand = {
 			description: "Preview rollback without executing",
 			default: false
 		},
+		"mark-only": {
+			type: "boolean",
+			description: "Record-only: mark migrations rolled back WITHOUT running any DOWN script (schema untouched)",
+			default: false,
+			short: "m"
+		},
 		force: {
 			type: "boolean",
 			description: "Skip confirmation prompt",
@@ -1252,6 +1696,7 @@ var dbRollbackCommand = {
 	handler: async (_args, options) => {
 		let db;
 		const dryRun = options["dry-run"] ?? options.dryRun;
+		const markOnly = options["mark-only"] ?? options.markOnly;
 		try {
 			const { getPackageConfig } = await import("@happyvertical/smrt-config");
 			const { DEFAULT_CLI_CONFIG } = await import("./config-BwrFRL8L.js");
@@ -1297,26 +1742,45 @@ var dbRollbackCommand = {
 				else console.log("✅ Nothing to rollback\n");
 				return;
 			}
+			const plan = migrationsToRollback.map((migration) => ({
+				migration,
+				recovery: recoverDownStatements(migration)
+			}));
+			const unrecoverable = plan.flatMap(({ migration, recovery }) => recovery.recoverable ? [] : [{
+				name: migration.name,
+				reason: recovery.reason
+			}]);
 			if (!options.json) {
 				console.log(`Migrations to rollback (${migrationsToRollback.length}):\n`);
-				for (const m of migrationsToRollback) {
-					const appliedAt = m.applied_at.toISOString().substring(0, 19);
-					console.log(`  ↩ ${m.name} (${shortChecksum(m.checksum)} applied ${appliedAt})`);
+				for (const { migration, recovery } of plan) {
+					const appliedAt = migration.applied_at.toISOString().substring(0, 19);
+					const marker = recovery.recoverable ? "↩" : "⊘";
+					console.log(`  ${marker} ${migration.name} (${shortChecksum(migration.checksum)} applied ${appliedAt})`);
+					if (recovery.recoverable) for (const sql of recovery.statements) console.log(`      ${sql};`);
+					else console.log(`      no DOWN script — ${recovery.reason}`);
 				}
 				console.log();
 			}
-			const nonReversible = migrationsToRollback.filter((m) => !m.is_reversible);
-			if (nonReversible.length > 0) if (options.json) console.log(JSON.stringify({
-				error: "Some migrations are not reversible",
-				nonReversible: nonReversible.map((m) => m.name)
-			}));
-			else {
-				console.log("⚠️  Warning: Some migrations are not reversible:\n");
-				for (const m of nonReversible) console.log(`   - ${m.name}`);
-				console.log("\n   These migrations will be marked as rolled back but no DOWN script will run.\n");
+			if (unrecoverable.length > 0 && !markOnly) {
+				if (options.json) console.log(JSON.stringify({
+					error: REFUSAL_ERROR,
+					dryRun: Boolean(dryRun),
+					unrecoverable,
+					nonReversible: unrecoverable.map((entry) => entry.name),
+					guidance: REFUSAL_GUIDANCE
+				}, null, 2));
+				else {
+					console.error(`❌ ${REFUSAL_HEADLINE}\n`);
+					for (const detail of unrecoverable) console.error(`   - ${detail.name} — ${detail.reason}`);
+					console.error();
+					for (const line of REFUSAL_GUIDANCE) console.error(`   ${line}`);
+					console.error("\n   Nothing was changed.\n");
+				}
+				process.exitCode = 1;
+				return;
 			}
 			if (!options.force && !dryRun && !options.json) {
-				console.log("⚠️  WARNING: This will revert database changes!");
+				console.log(markOnly ? "⚠️  WARNING: This marks migrations rolled back WITHOUT changing the schema!" : "⚠️  WARNING: This will revert database changes!");
 				const rl = (await import("node:readline/promises")).createInterface({
 					input: process.stdin,
 					output: process.stdout
@@ -1332,68 +1796,86 @@ var dbRollbackCommand = {
 			if (dryRun) {
 				if (options.json) console.log(JSON.stringify({
 					dryRun: true,
-					migrationsToRollback: migrationsToRollback.map((m) => ({
-						name: m.name,
-						checksum: m.checksum,
-						isReversible: m.is_reversible
+					markOnly: Boolean(markOnly),
+					migrationsToRollback: plan.map(({ migration, recovery }) => ({
+						name: migration.name,
+						checksum: migration.checksum,
+						isReversible: migration.is_reversible,
+						down: recovery.recoverable ? recovery.statements : []
 					}))
 				}));
 				else {
 					console.log("📋 Dry-run - no changes made\n");
-					console.log("Would rollback the following migrations:");
-					for (const m of migrationsToRollback) {
-						const status = m.is_reversible ? "(has DOWN script)" : "(no DOWN script)";
-						console.log(`  ↩ ${m.name} ${status}`);
+					console.log(markOnly ? "Would mark the following migrations rolled back (schema untouched):" : "Would execute the DOWN script of the following migrations:");
+					for (const { migration, recovery } of plan) {
+						const status = recovery.recoverable ? `↩ ${migration.name} (${recovery.statements.length} DOWN statement(s))` : `⊘ ${migration.name} (no DOWN script)`;
+						console.log(`  ${status}`);
 					}
 					console.log();
 				}
 				return;
 			}
-			if (!options.json) console.log("🔨 Rolling back migrations...\n");
+			if (!options.json) console.log(markOnly ? "🔨 Marking migrations rolled back (record-only)...\n" : "🔨 Rolling back migrations...\n");
 			let successCount = 0;
 			let errorCount = 0;
 			const results = [];
-			for (const migration of migrationsToRollback) try {
-				const definition = {
-					id: migration.name,
-					description: `Rollback: ${migration.name}`,
-					version: migration.version,
-					up: [],
-					down: []
-				};
-				if (migration.is_reversible) {
-					const result = await tracker.rollback(migration.name, definition, { dryRun: false });
-					if (result.success) {
-						if (!options.json) console.log(`  ✓ ${migration.name} rolled back`);
+			let stoppedBy = null;
+			for (const { migration, recovery } of plan) {
+				if (stoppedBy) {
+					const message = `Not attempted: rollback stopped after ${stoppedBy} failed`;
+					if (!options.json) console.error(`  ⊘ ${migration.name} skipped: ${message}`);
+					results.push({
+						name: migration.name,
+						success: false,
+						error: message
+					});
+					errorCount++;
+					continue;
+				}
+				try {
+					if (markOnly) {
+						await db.query(`UPDATE _smrt_schema_migrations SET status = 'rolled_back', rolled_back_at = CURRENT_TIMESTAMP WHERE name = ?`, [migration.name]);
+						if (!options.json) console.log(`  ⊙ ${migration.name} marked rolled back (schema untouched)`);
 						results.push({
 							name: migration.name,
-							success: true
+							success: true,
+							markedOnly: true
 						});
 						successCount++;
-					} else throw result.error || /* @__PURE__ */ new Error("Rollback failed");
-				} else {
-					await db.query(`UPDATE _smrt_schema_migrations SET status = 'rolled_back', rolled_back_at = CURRENT_TIMESTAMP WHERE name = ?`, [migration.name]);
-					if (!options.json) console.log(`  ⊙ ${migration.name} marked as rolled back (no DOWN script)`);
+						continue;
+					}
+					if (!recovery.recoverable) throw new Error(`No DOWN script available — ${recovery.reason}`);
+					const result = await tracker.rollback(migration.name, {
+						id: migration.name,
+						description: `Rollback: ${migration.name}`,
+						version: migration.version,
+						up: [],
+						down: recovery.statements
+					}, { dryRun: false });
+					if (!result.success) throw result.error || /* @__PURE__ */ new Error("Rollback failed");
+					if (!options.json) console.log(`  ✓ ${migration.name} rolled back`);
 					results.push({
 						name: migration.name,
 						success: true,
-						noDownScript: true
+						statements: recovery.statements
 					});
 					successCount++;
+				} catch (error) {
+					errorCount++;
+					const errorMsg = error instanceof Error ? error.message : String(error);
+					if (!options.json) console.error(`  ✗ ${migration.name} failed: ${errorMsg}`);
+					results.push({
+						name: migration.name,
+						success: false,
+						error: errorMsg
+					});
+					stoppedBy = migration.name;
+					if (options.verbose && error instanceof Error && error.stack) console.error(`\n${error.stack}\n`);
 				}
-			} catch (error) {
-				errorCount++;
-				const errorMsg = error instanceof Error ? error.message : String(error);
-				if (!options.json) console.error(`  ✗ ${migration.name} failed: ${errorMsg}`);
-				results.push({
-					name: migration.name,
-					success: false,
-					error: errorMsg
-				});
-				if (options.verbose && error instanceof Error && error.stack) console.error(`\n${error.stack}\n`);
 			}
 			if (options.json) console.log(JSON.stringify({
 				success: errorCount === 0,
+				markOnly: Boolean(markOnly),
 				successCount,
 				errorCount,
 				results
@@ -1401,6 +1883,7 @@ var dbRollbackCommand = {
 			else {
 				console.log();
 				if (errorCount > 0) console.log(`⚠️  Rollback completed with errors: ${successCount} succeeded, ${errorCount} failed\n`);
+				else if (markOnly) console.log(`✅ Marked ${successCount} migration(s) rolled back — the schema was NOT changed\n`);
 				else console.log(`✅ Successfully rolled back ${successCount} migration(s)\n`);
 				console.log("💡 Commands:");
 				console.log("   smrt db:status   - View current migration status");
@@ -1408,6 +1891,7 @@ var dbRollbackCommand = {
 				console.log("   smrt db:migrate  - Re-apply migrations");
 				console.log();
 			}
+			if (errorCount > 0) process.exitCode = 1;
 		} catch (error) {
 			if (options.json) console.log(JSON.stringify({ error: error instanceof Error ? error.message : String(error) }));
 			else {
@@ -1422,6 +1906,131 @@ var dbRollbackCommand = {
 	}
 };
 //#endregion
+//#region src/commands/db-parity.ts
+/**
+* Live-schema parity reporting for the CLI (#2368)
+*
+* Shared by `smrt doctor --db` and `smrt db:status --parity`. Both surfaces
+* introspect the configured database and compare it to the shape the model
+* layer assumes — including the hand-DDL `_smrt_*` system tables and an index
+* policy that does not consult the manifest, since the manifest is the artifact
+* that dropped the index in the first place (#2356).
+*
+* Everything here fails closed: a database that cannot be reached, or an
+* adapter that cannot describe its tables, is reported as a failure rather
+* than as "in sync".
+*/
+/**
+* Collect every declared upsert conflict target, keyed by table name.
+*
+* The conflict target is a registry property, not a manifest one: a class may
+* declare `conflictColumns` explicitly, inherit the CTI `(slug, context)`
+* default, or get the STI `(slug, context, _meta_type)` triple. Whatever it
+* resolves to, the live database needs a matching UNIQUE index or every upsert
+* against that table either errors (PostgreSQL) or duplicates rows.
+*/
+function collectRegistryConflictTargets() {
+	const targets = {};
+	for (const className of ObjectRegistry.getQualifiedClassNames()) {
+		const tableName = ObjectRegistry.getTableName(className);
+		if (!tableName) continue;
+		const columns = ObjectRegistry.getConflictColumns(className);
+		if (!columns || columns.length === 0) continue;
+		const bucket = targets[tableName] ?? [];
+		bucket.push({
+			columns,
+			source: className
+		});
+		targets[tableName] = bucket;
+	}
+	return targets;
+}
+/**
+* Run the parity check against the configured database.
+*
+* Never throws for an operational problem: connection and introspection
+* failures come back as `{ report: null, error }` so both callers can render
+* them in their own idiom while still failing closed.
+*/
+async function runLiveSchemaParity(options = {}) {
+	const { includeSystemTables = true, discover = true } = options;
+	let db;
+	try {
+		const { getPackageConfig } = await import("@happyvertical/smrt-config");
+		const { DEFAULT_CLI_CONFIG } = await import("./config-BwrFRL8L.js");
+		const config = getPackageConfig("cli", DEFAULT_CLI_CONFIG);
+		if (!config.database?.url || config.database.url === ":memory:") return {
+			report: null,
+			database: null,
+			error: "No persistent database is configured, so live-schema parity cannot be verified. Set `database.url` in smrt.config.ts (or DATABASE_URL)."
+		};
+		const dbUrl = config.database.url;
+		const dbType = config.database.type || "sqlite";
+		const database = {
+			type: dbType,
+			url: formatDatabaseDisplayUrl(dbType, dbUrl)
+		};
+		if (discover) await autoDiscoverAndLoad();
+		const { getDatabase } = await import("@happyvertical/sql");
+		db = await getDatabase({
+			type: dbType,
+			url: dbUrl
+		});
+		return {
+			report: await checkLiveSchemaParity({
+				db,
+				schemas: ObjectRegistry.getAllSchemasAsDefinitions(),
+				conflictTargets: collectRegistryConflictTargets(),
+				includeSystemTables,
+				engineHint: dbType
+			}),
+			database,
+			error: null
+		};
+	} catch (error) {
+		return {
+			report: null,
+			database: null,
+			error: error instanceof Error ? error.message : String(error)
+		};
+	} finally {
+		await closeDatabaseConnection(db);
+	}
+}
+var SEVERITY_ICON = {
+	error: "❌",
+	warning: "⚠️",
+	info: "ℹ️"
+};
+/** Findings of one severity, ordered by table then target. */
+function selectFindings(report, severity) {
+	return report.findings.filter((finding) => finding.severity === severity).sort((left, right) => left.table.localeCompare(right.table) || (left.target ?? "").localeCompare(right.target ?? ""));
+}
+/**
+* Render a parity report as console lines.
+*
+* Errors and warnings always print. Informational findings (undeclared tables,
+* columns and indexes) print only with `verbose`, because on a shared database
+* they are numerous and expected.
+*/
+function formatParityReport(report, options = {}) {
+	const lines = [];
+	lines.push(`   Engine: ${report.engine} · tables checked: ${report.tablesChecked}` + (report.tablesMissing > 0 ? ` · missing: ${report.tablesMissing}` : "") + (report.systemTablesIncluded ? " · system tables included" : ""));
+	if (report.indexIntrospection === "unavailable") lines.push("   ⚠️  Index metadata is not readable on this engine; index, uniqueness and conflict-target checks were skipped.");
+	const severities = options.verbose ? [
+		"error",
+		"warning",
+		"info"
+	] : ["error", "warning"];
+	for (const severity of severities) for (const finding of selectFindings(report, severity)) {
+		lines.push(`   ${SEVERITY_ICON[severity]} ${finding.message}`);
+		if (options.verbose) lines.push(`      → ${finding.recommendation}`);
+	}
+	if (report.counts.info > 0 && !options.verbose) lines.push(`   ℹ️  ${report.counts.info} informational finding(s) hidden; re-run with --verbose.`);
+	if (report.findings.length === 0) lines.push("   ✅ Live schema matches the expected shape.");
+	return lines;
+}
+//#endregion
 //#region src/commands/schema-contract.ts
 var SchemaContractError = class extends Error {
 	report;
@@ -1777,9 +2386,76 @@ function summarizeSchemaDiff(diff) {
 				recommendation: change.mismatch ? `Manual intervention required: expected ${change.mismatch.expected}, found ${change.mismatch.actual}.` : "Manual intervention required to reconcile this incompatible live column type."
 			});
 			break;
+		case "alter_column": {
+			const name = `${change.table}.${change.name ?? "(unknown)"}`;
+			const driftType = change.alteration === "set_not_null" || change.alteration === "drop_not_null" ? "nullability_drift" : "default_drift";
+			if (!Boolean(change.sql || change.sqlStatements?.length) && change.advisory) {
+				if (change.advisory.severity !== "warning") break;
+				drift.push({
+					name,
+					type: driftType,
+					recommendation: change.advisory.message
+				});
+			} else if (classifyTypeUpgradeSql(change.sql) === "executable") drift.push({
+				name,
+				type: driftType,
+				recommendation: `Run \`smrt db:migrate\` to repair this live column (${change.alteration ?? "alter_column"}: expected ${change.mismatch?.expected ?? "?"}, found ${change.mismatch?.actual ?? "?"}).`
+			});
+			else drift.push({
+				name,
+				type: driftType,
+				recommendation: change.advisory?.message ? `Manual intervention required: ${change.advisory.message}` : `Manual intervention required: expected ${change.mismatch?.expected ?? "?"}, found ${change.mismatch?.actual ?? "?"} (${change.alteration ?? "alter_column"}; cannot auto-apply on this database engine).`
+			});
+			break;
+		}
+		case "orphan_column":
+			if (change.advisory?.severity !== "warning") break;
+			drift.push({
+				name: `${change.table}.${change.name ?? "(unknown)"}`,
+				type: "orphan_column_blocking",
+				recommendation: change.advisory?.message ?? "Column exists in the database but not in the manifest."
+			});
+			break;
+		case "orphan_index":
+			drift.push({
+				name: `${change.table}.${change.name ?? "(unknown)"}`,
+				type: "orphan_unique_constraint",
+				recommendation: change.advisory?.message ?? "Unique constraint exists in the database but not in the manifest."
+			});
+			break;
+		case "drop_column":
+			drift.push({
+				name: `${change.table}.${change.name ?? "(unknown)"}`,
+				type: "orphan_column",
+				recommendation: "Run `smrt db:migrate --drop-columns` to drop this orphan column (destructive)."
+			});
+			break;
 	}
 	return drift;
 }
+/**
+* Info-level live-schema notes (#2369): harmless orphan columns, live
+* defaults the manifest no longer declares, and tables no loaded manifest
+* declares. Reported separately from `drift` so a JSON consumer counting
+* drift entries is not tripped by findings that need no action.
+*/
+function summarizeSchemaNotes(diff) {
+	const notes = [];
+	for (const change of diff.changes) {
+		if (Boolean(change.sql || change.sqlStatements?.length) || change.advisory?.severity !== "info") continue;
+		notes.push({
+			name: `${change.table}.${change.name ?? "(unknown)"}`,
+			type: change.type === "orphan_column" ? "orphan_column" : change.type === "alter_column" ? "default_drift" : change.type,
+			recommendation: change.advisory.message
+		});
+	}
+	for (const table of diff.orphan_tables ?? []) notes.push({
+		name: table,
+		type: "orphan_table",
+		recommendation: "Table exists in the database but no loaded manifest declares it. Not dropped; remove it manually if it is stale."
+	});
+	return notes;
+}
 var dbStatusCommand = {
 	name: "db:status",
 	description: "Show migration status (applied, pending, drift)",
@@ -1797,6 +2473,12 @@ var dbStatusCommand = {
 			description: "Show detailed migration information",
 			default: false,
 			short: "v"
+		},
+		parity: {
+			type: "boolean",
+			description: "Also compare the live schema to the expected shape (incl. _smrt_* system tables and index policy)",
+			default: false,
+			short: "p"
 		}
 	},
 	handler: async (_args, options) => {
@@ -1873,9 +2555,12 @@ var dbStatusCommand = {
 					}))
 				},
 				drift: [],
+				notes: [],
 				preconditions: [],
 				failedMigrations: summarizeFailedMigrations(failed, null),
-				schemaContract
+				schemaContract,
+				parity: null,
+				parityError: null
 			};
 			let diff = {
 				added_tables: [],
@@ -1887,6 +2572,7 @@ var dbStatusCommand = {
 				const manifestSchemas = ObjectRegistry.getAllSchemasAsDefinitions();
 				diff = await new SchemaComparer(db).compare(manifestSchemas);
 				status.drift = summarizeSchemaDiff(diff);
+				status.notes = summarizeSchemaNotes(diff);
 				status.preconditions = await checkTenantIdUuidPreconditions({
 					db,
 					dbType,
@@ -1894,7 +2580,18 @@ var dbStatusCommand = {
 					manifestSchemas
 				});
 				status.failedMigrations = summarizeFailedMigrations(failed, getUnresolvedGeneratedMigrationNames(diff.changes));
-			}
+				if (options.parity) try {
+					status.parity = await checkLiveSchemaParity({
+						db,
+						schemas: manifestSchemas,
+						conflictTargets: collectRegistryConflictTargets(),
+						includeSystemTables: true,
+						engineHint: dbType
+					});
+				} catch (error) {
+					status.parityError = error instanceof Error ? error.message : String(error);
+				}
+			} else if (options.parity) status.parityError = "The configured database adapter cannot describe tables, so live-schema parity cannot be verified.";
 			const failedAssessments = assessFailedMigrations(failed, typeof db.getTableSchema === "function" ? diff : null);
 			status.migrations.failed = {
 				total: failedAssessments.length,
@@ -1903,9 +2600,10 @@ var dbStatusCommand = {
 				manualReview: failedAssessments.filter((item) => item.resolution === "manual_review").length,
 				details: failedAssessments
 			};
+			const parityFailed = status.parityError !== null || status.parity?.ok === false;
 			if (options.json) {
 				console.log(JSON.stringify(status, null, 2));
-				if (!schemaContract.ok || status.preconditions.some((item) => item.status === "error")) process.exitCode = 1;
+				if (!schemaContract.ok || parityFailed || status.preconditions.some((item) => item.status === "error")) process.exitCode = 1;
 				return;
 			}
 			console.log(`📦 Manifests: ${status.manifests.count} discovered`);
@@ -1949,6 +2647,25 @@ var dbStatusCommand = {
 				console.log("✅ Live schema matches current manifests");
 				console.log();
 			}
+			if (status.notes.length > 0) {
+				console.log(`ℹ️  Live schema notes (${status.notes.length}, no action required):`);
+				for (const note of status.notes) {
+					console.log(`   • ${note.name}: ${note.type}`);
+					if (options.verbose) console.log(`     ${note.recommendation}`);
+				}
+				console.log();
+			}
+			if (options.parity) {
+				console.log("🗄️  Live Schema Parity:");
+				if (status.parityError) {
+					console.log(`   ❌ ${status.parityError}`);
+					process.exitCode = 1;
+				} else if (status.parity) {
+					for (const line of formatParityReport(status.parity, { verbose: options.verbose })) console.log(line);
+					if (!status.parity.ok) process.exitCode = 1;
+				}
+				console.log();
+			}
 			if (!schemaContract.ok) {
 				console.log("❌ Schema Contract Failed:");
 				console.log(formatSchemaContractFailures(schemaContract));
@@ -6512,6 +7229,15 @@ async function repairStiDiscriminatorRows(options) {
 *
 * Commands for introspection, testing, and project management
 */
+/**
+* Fallbacks for `migrations.postgres.lockTimeout` / `.statementTimeout`.
+*
+* These mirror `DEFAULT_CLI_CONFIG.migrations.postgres` ('30s' / '60s') so a
+* project that never wrote a `migrations` block still gets a bounded
+* PostgreSQL migration rather than an unbounded lock wait (issue #2362).
+*/
+var DEFAULT_MIGRATION_LOCK_TIMEOUT_MS = 3e4;
+var DEFAULT_MIGRATION_STATEMENT_TIMEOUT_MS = 6e4;
 function formatSchemaCommandFailureHeader(error, fallback) {
 	if (error instanceof SchemaContractError) return "\n❌ Schema contract failed:";
 	if (error instanceof UnsupportedFileMigrationsError) return "\n❌ File-backed migrations are not supported:";
@@ -6543,6 +7269,28 @@ function resolveDDLPreviewEngine(dbType) {
 		default: return "sqlite";
 	}
 }
+/**
+* Run the framework's deferred system-table compatibility pass after
+* `db:migrate` has created the tables it reshapes (issue #2376).
+*
+* `_smrt_jobs` and `_smrt_job_events` are dual-owned — created here from the
+* jobs manifest, then given their compatibility columns and indexes by
+* `@happyvertical/smrt-core`. On a fresh install the framework bootstrap runs
+* before those tables exist, so without this call the pass would first become
+* reachable at the next process start.
+*
+* Best-effort: the pass is idempotent and re-runs on the next boot, so a
+* failure here must not fail an otherwise-successful migration.
+*/
+async function settleDeferredCompatibilityAfterMigrate(db, dbType, { verbose }) {
+	try {
+		const { settled } = await ensureDeferredSystemTableCompatibility(db, dbType);
+		if (verbose) console.log(settled ? "Deferred system-table compatibility settled (_smrt_jobs, _smrt_job_events)\n" : "Deferred system-table compatibility pending (jobs tables not present)\n");
+	} catch (error) {
+		console.warn(`⚠️  Deferred system-table compatibility did not complete: ${error instanceof Error ? error.message : String(error)}`);
+		console.warn("   It will be retried the next time the framework starts.\n");
+	}
+}
 function formatStiConflictIdentity(conflict) {
 	const entries = Object.entries(conflict.conflictIdentity);
 	return `${entries.length > 0 ? entries.map(([column, value]) => `${column}=${JSON.stringify(value)}`).join(", ") : "no non-_meta_type conflict columns"}${conflict.legacyId || conflict.qualifiedId ? ` (legacy id: ${conflict.legacyId ?? "unknown"}, qualified id: ${conflict.qualifiedId ?? "unknown"})` : ""}`;
@@ -6584,6 +7332,79 @@ function assertForceMigrationTargetsExist(forceMigrations, generatedMigrationIds
 	const unknown = forceMigrations.filter((migrationId) => !generated.has(migrationId));
 	if (unknown.length > 0) throw new Error(`--force-migration target${unknown.length === 1 ? "" : "s"} not found in the current generated migration batch: ${unknown.join(", ")}`);
 }
+/**
+* Match an actual `oxc: { … decorator: … }` configuration block.
+*
+* Deliberately stricter than "the words `oxc` and `decorator` both appear":
+* a stray mention in a comment or an unrelated import would otherwise mark the
+* transform configured on a Vite 8 project that throws
+* `SyntaxError: Invalid or unexpected token` on its first SSR request — the
+* exact failure this check exists to catch. The lazy body stops at the first
+* `decorator:` key after the `oxc` object opens.
+*
+* A config that assembles `oxc` indirectly (a spread, or an imported base
+* config) is reported as unconfigured. That direction is the safe one: the
+* recommendation names the exact key to add, whereas the opposite error is
+* silent until runtime.
+*/
+var OXC_DECORATOR_BLOCK_RE = /\boxc\s*:\s*\{[\s\S]*?\bdecorator\s*:/;
+/**
+* Read the declared Vite major version from a project's package.json.
+*
+* Returns `null` when Vite is absent or the range is not a simple one whose
+* major can be read off the front (`workspace:*`, `*`, a git URL, …); callers
+* treat that as "unknown major" and accept either decorator recipe.
+*/
+function resolveDeclaredViteMajor(packageJson) {
+	const range = packageJson.devDependencies?.vite ?? packageJson.dependencies?.vite;
+	if (typeof range !== "string") return null;
+	const match = range.match(/(\d+)\s*\./);
+	if (!match) return null;
+	const major = Number.parseInt(match[1], 10);
+	return Number.isFinite(major) ? major : null;
+}
+/**
+* Assess whether a project's decorator transform is actually configured.
+*
+* The doctor used to require `experimentalDecorators` in tsconfig.json
+* unconditionally, which contradicts the framework's own Vite 8 guidance: the
+* oxc transform does not honor tsconfig `experimentalDecorators` (nor the
+* pre-Vite-8 `esbuild.tsconfigRaw` recipe), so a correctly configured Vite 8
+* project — decorators declared under `oxc.decorator` — was reported broken,
+* and a Vite 8 project relying on tsconfig alone was reported healthy right up
+* until the first SSR request threw `SyntaxError: Invalid or unexpected token`.
+*
+* The check now follows the documented recipe per Vite major:
+* - Vite 8+: `oxc.decorator` in vite.config is the only working configuration.
+* - Vite <8 (or no declared Vite): tsconfig `experimentalDecorators` is the
+*   legacy recipe and remains valid.
+*/
+function assessDecoratorSupport(input) {
+	const { viteMajor, viteConfigContent, tsconfigContent } = input;
+	const hasOxcDecorator = viteConfigContent !== null && OXC_DECORATOR_BLOCK_RE.test(viteConfigContent);
+	const hasTsconfigDecorators = tsconfigContent?.includes("experimentalDecorators");
+	const isVite8Plus = viteMajor !== null && viteMajor >= 8;
+	if (hasOxcDecorator) return {
+		status: "ok",
+		message: "oxc.decorator configured in vite.config"
+	};
+	if (isVite8Plus) return {
+		status: "error",
+		message: hasTsconfigDecorators ? "Vite 8 ignores tsconfig experimentalDecorators - add oxc: { decorator: { legacy: true, emitDecoratorMetadata: true } } to vite.config" : "Add oxc: { decorator: { legacy: true, emitDecoratorMetadata: true } } to vite.config (required for @smrt() under Vite 8+)"
+	};
+	if (hasTsconfigDecorators) return {
+		status: "ok",
+		message: "experimentalDecorators enabled in tsconfig.json"
+	};
+	if (viteConfigContent === null && tsconfigContent === null) return {
+		status: "warning",
+		message: "No vite.config or tsconfig.json found - configure the decorator transform wherever this project compiles @smrt() classes"
+	};
+	return {
+		status: "error",
+		message: "No decorator transform configured - add oxc: { decorator: { legacy: true, emitDecoratorMetadata: true } } to vite.config (Vite 8+), or \"experimentalDecorators\": true to tsconfig.json (vite<8)"
+	};
+}
 function getErrorContext(error) {
 	if (error && typeof error === "object" && "context" in error) {
 		const context = error.context;
@@ -7141,7 +7962,7 @@ export default testManifest;
 			},
 			"postgres-safe": {
 				type: "boolean",
-				description: "Use PostgreSQL-safe operations (CONCURRENTLY for indexes, lock_timeout)",
+				description: "PostgreSQL concurrent-index mode: commit non-index DDL atomically, then build each index with CREATE INDEX CONCURRENTLY outside that transaction. Trades batch atomicity for availability; lock_timeout/statement_timeout apply either way.",
 				default: false
 			},
 			"postgres-timestamp-legacy-timezone": {
@@ -7173,6 +7994,16 @@ export default testManifest;
 				description: "Drop orphan indexes (in DB but not in manifest, excluding *_pkey/*_key implicit-from-constraint indexes). Off by default.",
 				default: false
 			},
+			"drop-columns": {
+				type: "boolean",
+				description: "DESTRUCTIVE: drop orphan columns (in DB but not in manifest). Off by default; orphans are always reported.",
+				default: false
+			},
+			"relax-columns": {
+				type: "boolean",
+				description: "Apply constraint relaxations the manifest implies: DROP NOT NULL / DROP DEFAULT on live columns stricter than the manifest, and DROP NOT NULL on orphan NOT NULL columns (PostgreSQL/DuckDB). Off by default; relaxations are always reported.",
+				default: false
+			},
 			verbose: {
 				type: "boolean",
 				description: "Show detailed output",
@@ -7266,16 +8097,26 @@ export default testManifest;
 				console.log(`✓ Connected to ${formatDatabaseDisplayUrl(dbType, dbUrl)}\n`);
 				const systemTimestampPreview = postgresTimestampMigration && isDryRun ? await planPostgresSystemTimestampMigrations(db, postgresTimestampMigration, dbType) : [];
 				if (postgresTimestampMigration && !isDryRun) await migratePostgresSystemTimestamps(db, postgresTimestampMigration, dbType);
-				const { MigrationTracker, shortChecksum } = await import("@happyvertical/smrt-core/migrations");
+				const { buildConcurrentIndexPlan, MigrationTracker, parsePostgresTimeoutMs, shortChecksum } = await import("@happyvertical/smrt-core/migrations");
+				const postgresMigrationConfig = config.migrations?.postgres;
+				const lockTimeout = parsePostgresTimeoutMs(postgresMigrationConfig?.lockTimeout, DEFAULT_MIGRATION_LOCK_TIMEOUT_MS);
+				const statementTimeout = parsePostgresTimeoutMs(postgresMigrationConfig?.statementTimeout, DEFAULT_MIGRATION_STATEMENT_TIMEOUT_MS);
+				const concurrentIndexMode = Boolean(options["postgres-safe"]) && (postgresMigrationConfig?.useConcurrently ?? true);
 				const tracker = new MigrationTracker({
 					db,
-					useConcurrentIndexes: options["postgres-safe"] ?? false
+					lockTimeout,
+					statementTimeout,
+					useConcurrentIndexes: concurrentIndexMode
 				});
 				if (!isDryRun) await tracker.initialize();
 				if (options.verbose) {
 					const engine = tracker.getEngine();
 					console.log(isDryRun ? `Migration tracker preview configured (engine: ${engine})` : `Migration tracker initialized (engine: ${engine})`);
-					if (options["postgres-safe"] && engine === "postgres") console.log("PostgreSQL-safe mode enabled (CONCURRENTLY, lock_timeout)");
+					if (engine === "postgres") {
+						console.log(`PostgreSQL lock_timeout: ${lockTimeout}ms, statement_timeout: ${statementTimeout}ms`);
+						if (concurrentIndexMode) console.log("PostgreSQL concurrent-index mode enabled (CREATE INDEX CONCURRENTLY outside the atomic batch)");
+						else if (options["postgres-safe"]) console.log("PostgreSQL concurrent-index mode disabled by migrations.postgres.useConcurrently = false");
+					}
 					console.log();
 				}
 				const migrations = [];
@@ -7290,6 +8131,8 @@ export default testManifest;
 				console.log("🔍 Comparing schemas...\n");
 				const diff = await new SchemaComparer(db, {
 					includeDroppedIndexes: Boolean(options["drop-indexes"]),
+					includeDroppedColumns: Boolean(options["drop-columns"]),
+					relaxColumns: Boolean(options["relax-columns"]),
 					postgresTimestampMigration
 				}).compare(manifestSchemas);
 				const getClassForTable = (tableName) => {
@@ -7308,6 +8151,7 @@ export default testManifest;
 				const partitionedChanges = partitionSchemaChanges(diff.changes, getClassForTable);
 				migrations.push(...partitionedChanges.migrations);
 				manualInterventions.push(...partitionedChanges.manualInterventions);
+				const advisories = partitionedChanges.advisories;
 				assertForceMigrationTargetsExist(forceSelection.forceMigrations, [...diff.added_tables.map((schema) => `create_table_${schema.tableName}`), ...migrations.flatMap((migration) => {
 					const migrationName = getSyntheticMigrationNameForAction(migration);
 					return migrationName ? [migrationName] : [];
@@ -7317,17 +8161,22 @@ export default testManifest;
 					console.log("⚠️  Schema drift detected that requires manual intervention:\n");
 					for (const change of manualInterventions) {
 						if (!change.mismatch) continue;
-						const detail = change.type === "type_upgrade" ? `${change.tableName}.${change.mismatch.column}: expected ${change.mismatch.expected}, found ${change.mismatch.actual} (cannot auto-apply on this database engine)` : `${change.tableName}.${change.mismatch.column}: expected ${change.mismatch.expected}, found ${change.mismatch.actual}`;
+						const detail = change.type === "type_upgrade" ? `${change.tableName}.${change.mismatch.column}: expected ${change.mismatch.expected}, found ${change.mismatch.actual} (cannot auto-apply on this database engine)` : change.type === "alter_column" ? `${change.tableName}.${change.mismatch.column}: expected ${change.mismatch.expected}, found ${change.mismatch.actual} (${change.alteration ?? "alter_column"}; ${change.sql?.replace(/^--\s*/, "") ?? "cannot auto-apply on this database engine"})` : `${change.tableName}.${change.mismatch.column}: expected ${change.mismatch.expected}, found ${change.mismatch.actual}`;
 						console.log(`   ${detail}`);
 					}
 					console.log();
 					console.log("   Manual migration required (backup, recreate, restore as needed).\n");
 				}
+				printSchemaAdvisories(advisories, {
+					orphanTables: diff.orphan_tables ?? [],
+					verbose: Boolean(options.verbose)
+				});
 				const tablesCreated = diff.added_tables.length > 0;
 				const schemaUpToDate = migrations.length === 0 && manualInterventions.length === 0 && !tablesCreated && systemTimestampPreview.length === 0;
+				const upToDateMessage = advisories.some((a) => a.advisory.severity === "warning") ? "✅ No migrations needed - see the live schema findings above\n" : "✅ Database schema is up to date - no migrations needed\n";
 				if (isDryRun) {
 					if (schemaUpToDate && !repairData) {
-						console.log("✅ Database schema is up to date - no migrations needed\n");
+						console.log(upToDateMessage);
 						return;
 					}
 					if (schemaUpToDate) console.log("✅ Database schema is up to date - no schema migrations needed\n");
@@ -7341,11 +8190,23 @@ export default testManifest;
 						const columnMigrations = migrations.filter((m) => m.type === "add_column");
 						const indexMigrations = migrations.filter((m) => m.type === "add_index");
 						const indexDrops = migrations.filter((m) => m.type === "drop_index");
+						const columnAlterations = migrations.filter((m) => m.type === "alter_column");
+						const columnDrops = migrations.filter((m) => m.type === "drop_column");
 						if (columnMigrations.length > 0) {
 							console.log(`  📊 Columns to add: ${columnMigrations.length}`);
 							for (const m of columnMigrations) console.log(`     ${m.tableName}.${m.column?.name} (${m.column?.type})`);
 							console.log();
 						}
+						if (columnAlterations.length > 0) {
+							console.log(`  🔧 Columns to alter: ${columnAlterations.length}`);
+							for (const m of columnAlterations) console.log(`     ${m.tableName}.${m.columnName ?? m.column?.name} (${m.alteration ?? "alter"}: ${m.mismatch?.actual ?? "?"} → ${m.mismatch?.expected ?? "?"})`);
+							console.log();
+						}
+						if (columnDrops.length > 0) {
+							console.log(`  🗑️  Columns to drop (DESTRUCTIVE, --drop-columns): ${columnDrops.length}`);
+							for (const m of columnDrops) console.log(`     ${m.tableName}.${m.columnName}`);
+							console.log();
+						}
 						if (indexDrops.length > 0) {
 							console.log(`  🗑️  Indexes to drop: ${indexDrops.length}`);
 							for (const m of indexDrops) console.log(`     ${m.indexName} on ${m.tableName}`);
@@ -7378,7 +8239,6 @@ export default testManifest;
 				let errorCount = 0;
 				let stiErrorCount = 0;
 				const schemaChangeCount = diff.added_tables.length + migrations.length;
-				if (applySchemaMigrations && schemaChangeCount > 0) console.log(`🔨 Applying ${schemaChangeCount} schema change(s) atomically...\n`);
 				if (applySchemaMigrations && schemaChangeCount > 0) {
 					const migrationDefs = [];
 					const migrationLogs = /* @__PURE__ */ new Map();
@@ -7410,6 +8270,12 @@ export default testManifest;
 						if (migration.type === "add_column" && migration.column) {
 							migrationSql = migration.sql || "";
 							actionDesc = `Added column ${migration.tableName}.${migration.column.name}`;
+						} else if (migration.type === "alter_column" && (migration.columnName || migration.column)) {
+							migrationSql = migration.sql || "";
+							actionDesc = `Altered column ${migration.tableName}.${migration.columnName ?? migration.column?.name} (${migration.alteration ?? "alter"})`;
+						} else if (migration.type === "drop_column" && migration.columnName) {
+							migrationSql = migration.sql || "";
+							actionDesc = `Dropped column ${migration.tableName}.${migration.columnName}`;
 						} else if (migration.type === "type_upgrade" && migration.column) {
 							migrationSql = migration.sql || "";
 							actionDesc = `Upgraded column ${migration.tableName}.${migration.column.name} from ${migration.mismatch?.actual} to ${migration.mismatch?.expected}`;
@@ -7423,7 +8289,7 @@ export default testManifest;
 						const migrationSqlStatements = migration.sqlStatements ?? (migrationSql ? [migrationSql] : []);
 						migrationDefs.push({
 							id: migrationName,
-							description: migration.type === "add_column" ? `Add column ${migration.column?.name} to ${migration.tableName}` : migration.type === "type_upgrade" ? `Upgrade column ${migration.column?.name} on ${migration.tableName} from ${migration.mismatch?.actual} to ${migration.mismatch?.expected}` : migration.type === "drop_index" ? `Drop index ${migration.indexName} on ${migration.tableName}` : `Add index ${migration.index?.name} on ${migration.tableName}`,
+							description: migration.type === "add_column" ? `Add column ${migration.column?.name} to ${migration.tableName}` : migration.type === "alter_column" ? `Alter column ${migration.columnName ?? migration.column?.name} on ${migration.tableName} (${migration.alteration ?? "alter"}: ${migration.mismatch?.actual ?? "?"} → ${migration.mismatch?.expected ?? "?"})` : migration.type === "drop_column" ? `Drop column ${migration.columnName} from ${migration.tableName}` : migration.type === "type_upgrade" ? `Upgrade column ${migration.column?.name} on ${migration.tableName} from ${migration.mismatch?.actual} to ${migration.mismatch?.expected}` : migration.type === "drop_index" ? `Drop index ${migration.indexName} on ${migration.tableName}` : `Add index ${migration.index?.name} on ${migration.tableName}`,
 							version: "1.0.0",
 							up: migrationSqlStatements,
 							down: []
@@ -7433,14 +8299,20 @@ export default testManifest;
 							skippedMessage: `${migrationName} already applied`
 						});
 					}
-					if (options["postgres-safe"] && engine === "postgres" && migrations.some((migration) => migration.type === "add_index" || migration.type === "drop_index")) {
-						console.warn("⚠️  --postgres-safe requested, but db:migrate applies generated schema changes atomically.");
-						console.warn("   Index DDL in this batch will run without CONCURRENTLY so PostgreSQL can roll back the full batch on failure.\n");
+					const deferredIndexMigrations = concurrentIndexMode && engine === "postgres" ? buildConcurrentIndexPlan(migrationDefs, true).size : 0;
+					const batchHasIndexDDL = migrations.some((migration) => migration.type === "add_index" || migration.type === "drop_index");
+					console.log(deferredIndexMigrations > 0 ? `🔨 Applying ${schemaChangeCount} schema change(s) (non-index DDL atomically, ${deferredIndexMigrations} index migration(s) CONCURRENTLY)...\n` : `🔨 Applying ${schemaChangeCount} schema change(s) atomically...\n`);
+					if (deferredIndexMigrations > 0) {
+						console.warn("⚠️  PostgreSQL concurrent-index mode: index DDL runs CONCURRENTLY after the non-index batch commits.");
+						console.warn("   This batch is therefore NOT atomic — committed column/table changes survive a later index failure, and unfinished index migrations are recorded failed so the next db:migrate retries them.\n");
+					} else if (engine === "postgres" && batchHasIndexDDL && options["postgres-safe"] && !concurrentIndexMode) {
+						console.warn("⚠️  --postgres-safe requested, but migrations.postgres.useConcurrently is false.");
+						console.warn("   Index DDL in this batch will run inside the atomic transaction (bounded by lock_timeout/statement_timeout).\n");
 					}
 					try {
 						const results = await tracker.applyAll(migrationDefs, {
 							atomic: true,
-							postgresSafe: false,
+							postgresSafe: concurrentIndexMode,
 							force: forceSelection.force,
 							forceMigrations: forceSelection.forceMigrations,
 							reconcile: true,
@@ -7465,10 +8337,10 @@ export default testManifest;
 						console.error(`  ✗ atomic schema migration failed: ${errorMsg}`);
 						if (error instanceof Error && getErrorContext(error)?.originalError) console.error(`     Cause: ${getErrorContext(error)?.originalError}`);
 						if (options.verbose && error instanceof Error && error.stack) console.error(`\n${error.stack}\n`);
-						console.error("     Rolled back all schema changes from this migration batch, including any successful steps shown above.");
+						console.error(deferredIndexMigrations > 0 ? "     Non-index changes in this batch were committed; concurrent index builds that did not finish are recorded failed and will be retried on the next db:migrate." : "     Rolled back all schema changes from this migration batch, including any successful steps shown above.");
 					}
 				}
-				if (schemaUpToDate && !repairData) console.log("✅ Database schema is up to date - no migrations needed\n");
+				if (schemaUpToDate && !repairData) console.log(upToDateMessage);
 				if (repairData) {
 					console.log("\n🔄 Repairing STI discriminators to qualified names...\n");
 					const allTableNames = /* @__PURE__ */ new Set();
@@ -7564,11 +8436,14 @@ export default testManifest;
 					stiErrorCount,
 					dryRun: isDryRun
 				})) process.exitCode = 1;
-				if (!isDryRun) assertSchemaContract(await evaluateSchemaContract({
-					discovered,
-					schemaContract: config.schemaContract,
-					db
-				}));
+				if (!isDryRun) {
+					await settleDeferredCompatibilityAfterMigrate(db, dbType, { verbose: Boolean(options.verbose) });
+					assertSchemaContract(await evaluateSchemaContract({
+						discovered,
+						schemaContract: config.schemaContract,
+						db
+					}));
+				}
 				console.log("💡 Next steps:");
 				console.log("  - Run: smrt db:status (view migration status)");
 				console.log("  - Run: smrt db:history (view migration history)");
@@ -7607,6 +8482,17 @@ export default testManifest;
 				default: false,
 				short: "f"
 			},
+			db: {
+				type: "boolean",
+				description: "Compare the live database to the expected schema shape (incl. _smrt_* system tables)",
+				default: false
+			},
+			verbose: {
+				type: "boolean",
+				description: "Show recommendations and informational findings",
+				default: false,
+				short: "v"
+			},
 			"generation-snapshot": {
 				type: "string",
 				description: "Verify a transported SMRT generation snapshot"
@@ -7713,14 +8599,22 @@ export default testManifest;
 			const viteConfigJs = resolve(cwd, "vite.config.js");
 			const hasViteConfig = existsSync(viteConfigTs) || existsSync(viteConfigJs);
 			check("vite.config.ts/js exists", hasViteConfig, void 0, "Missing vite.config (optional for non-Vite projects)");
-			if (hasViteConfig) check("smrtPlugin in vite.config", readFileSync(existsSync(viteConfigTs) ? viteConfigTs : viteConfigJs, "utf-8").includes("smrtPlugin"), "Missing smrtPlugin - add: import { smrtPlugin } from \"@happyvertical/smrt-core/vite-plugin\"");
+			const viteConfigContent = hasViteConfig ? readFileSync(existsSync(viteConfigTs) ? viteConfigTs : viteConfigJs, "utf-8") : null;
+			if (viteConfigContent !== null) check("smrtPlugin in vite.config", viteConfigContent.includes("smrtPlugin"), "Missing smrtPlugin - add: import { smrtPlugin } from \"@happyvertical/smrt-core/vite-plugin\"");
 			const tsconfigPath = resolve(cwd, "tsconfig.json");
+			let tsconfigContent = null;
 			if (existsSync(tsconfigPath)) try {
-				check("experimentalDecorators enabled", readFileSync(tsconfigPath, "utf-8").includes("experimentalDecorators"), "Add \"experimentalDecorators\": true to tsconfig.json");
+				tsconfigContent = readFileSync(tsconfigPath, "utf-8");
 			} catch {
 				check("tsconfig.json readable", false, "Could not read tsconfig.json");
 			}
 			else check("tsconfig.json exists", false, void 0, "No tsconfig.json found (optional for JavaScript projects)");
+			const decoratorSupport = assessDecoratorSupport({
+				viteMajor: resolveDeclaredViteMajor(packageJson),
+				viteConfigContent,
+				tsconfigContent
+			});
+			check("Decorator transform configured", decoratorSupport.status === "ok", decoratorSupport.status === "error" ? decoratorSupport.message : void 0, decoratorSupport.status === "warning" ? decoratorSupport.message : void 0);
 			console.log();
 			console.log("📦 SMRT Objects\n");
 			const objectsDir = resolve(cwd, "src/lib/objects");
@@ -7774,6 +8668,21 @@ export default testManifest;
 			else if (existsSync(envExamplePath)) check(".env file exists", false, void 0, ".env.example exists - copy it to .env");
 			else check(".env file exists", false, void 0, "No .env file - environment variables may be needed");
 			console.log();
+			if (options.db) {
+				console.log("🗄️  Live Database Parity\n");
+				const { report, error, database } = await runLiveSchemaParity({ discover: false });
+				if (!report) check("Live schema parity", false, error ?? "Could not verify the live schema");
+				else {
+					if (database) console.log(`   Database: ${database.url}`);
+					for (const line of formatParityReport(report, { verbose: options.verbose })) console.log(line);
+					const parityErrors = selectFindings(report, "error");
+					const parityWarnings = selectFindings(report, "warning");
+					for (const finding of parityErrors) issues.push(`live schema: ${finding.table}${finding.target ? `.${finding.target}` : ""} (${finding.kind})`);
+					for (const finding of parityWarnings) warnings.push(`live schema: ${finding.table}${finding.target ? `.${finding.target}` : ""} (${finding.kind})`);
+					if (parityErrors.length === 0 && parityWarnings.length === 0) passed.push("Live schema parity");
+				}
+				console.log();
+			}
 			console.log("━".repeat(50));
 			console.log(`\n📊 Summary\n`);
 			console.log(`   ✅ Passed:   ${passed.length}`);
@@ -7805,6 +8714,7 @@ export default testManifest;
 	"db:rollback": dbRollbackCommand,
 	"db:generate": dbGenerateCommand,
 	"db:migrate-uuid": dbMigrateUuidCommand,
+	"db:prune": dbPruneCommand,
 	"config:export": configExportCommand,
 	export: exportCommand
 };