@happyvertical/smrt-cli 0.42.6 → 0.43.0

package/AGENTS.md

@@ -43,6 +43,18 @@ migrations are manifest-driven through registered objects and project manifests.
 
 ## `db:migrate` on PostgreSQL
 
+New tables are created in deterministic foreign-key dependency order. Mutual
+cycles are created without the cyclic clauses first, then receive named
+constraints after both tables exist. When a same-package constraint is missing
+on an existing table, `db:migrate` probes the exact child/parent columns for
+orphans before `ADD ... NOT VALID` and `VALIDATE CONSTRAINT`; orphaned data or a
+failed probe stays manual with detector/repair SQL.
+
+`db:migrate --dry-run` and deprecated `db:setup --dry-run` print the same
+engine-specific dependency plan used for execution, including exact table DDL
+and deferred PostgreSQL cycle constraints; cached per-class DDL is not a valid
+preview.
+
 `db:migrate` always bounds a PostgreSQL batch with `SET LOCAL lock_timeout` and
 `SET LOCAL statement_timeout` inside its transaction, from
 `migrations.postgres.lockTimeout` / `.statementTimeout` (defaults `30s` / `60s`;
@@ -105,6 +117,13 @@ not from the schema definition.
 
 ## `db:migrate` on SQLite: type changes rebuild the table
 
+SQLite can enforce generated same-package constraints on new tables, including
+cycles, but adding one to an existing table requires an explicit rebuild.
+DuckDB reports unsupported constraint shapes or `ALTER ADD CONSTRAINT` as
+manual/refused work, never as a successful no-op. Generated same-package
+constraints retain `ON UPDATE CASCADE`, which DuckDB/JSON cannot enforce, so
+those engines report an actionable refusal rather than silently stripping it.
+
 SQLite has no `ALTER COLUMN ... TYPE`, so a type-bucket change (the common one
 being a numeric default edited `0` → `0.0`) is applied as the documented table
 rebuild — stage, copy, drop, rename, replay indexes and triggers — planned by

package/dist/{commands-BOw91sjd.js → commands-C1bK8bv9.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, checkLiveSchemaParity, createQualifiedName, ensureDeferredSystemTableCompatibility, generateDDLForEngine, getClassName, isQualifiedName, migratePostgresSystemTimestamps, parseQualifiedName, planPostgresSystemTimestampMigrations } from "@happyvertical/smrt-core";
+import { ObjectRegistry, SchemaComparer, checkLiveSchemaParity, createQualifiedName, ensureDeferredSystemTableCompatibility, generateDDLForEngine, getClassName, isQualifiedName, migratePostgresSystemTimestamps, parseQualifiedName, planForeignKeyCreation, 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";
@@ -489,6 +489,10 @@ function getSyntheticMigrationNameForAction(action) {
 			const fingerprint = sqlShapeFingerprint(action);
 			return fingerprint ? `add_index_${action.index.name}_${fingerprint}` : `add_index_${action.index.name}`;
 		}
+		case "add_foreign_key": {
+			const fingerprint = sqlShapeFingerprint(action);
+			return fingerprint ? `add_foreign_key_${action.tableName}_${fingerprint}` : null;
+		}
 		case "drop_index": {
 			if (!action.indexName) return null;
 			const fingerprint = sqlShapeFingerprint(action);
@@ -517,6 +521,10 @@ function getSyntheticMigrationNameForChange(change) {
 			});
 			return fingerprint ? `add_index_${indexName}_${fingerprint}` : `add_index_${indexName}`;
 		}
+		case "add_foreign_key": {
+			const fingerprint = sqlShapeFingerprint(change);
+			return fingerprint ? `add_foreign_key_${change.table}_${fingerprint}` : null;
+		}
 		case "drop_index": {
 			if (!change.name) return null;
 			const fingerprint = sqlShapeFingerprint({
@@ -557,13 +565,13 @@ function shouldApplySchemaMigrations(state) {
 	return !state.dryRun;
 }
 function classifyFailedMigration(migrationName, unresolvedSyntheticMigrationNames) {
-	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";
+	if (!migrationName.startsWith("add_column_") && !migrationName.startsWith("drop_column_") && !migrationName.startsWith("alter_column_") && !migrationName.startsWith("add_foreign_key_") && !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 !== "drop_column" && change.type !== "alter_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_foreign_key" && 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);
@@ -706,6 +714,19 @@ function partitionSchemaChanges(changes, getClassForTable) {
 				});
 				break;
 			}
+			case "add_foreign_key": {
+				const action = {
+					type: "add_foreign_key",
+					tableName: change.table,
+					className,
+					sql: change.sql,
+					...change.sqlStatements ? { sqlStatements: change.sqlStatements } : {},
+					advisory: change.advisory
+				};
+				if (isAdvisoryOnlyChangeLike(change)) manualInterventions.push(action);
+				else migrations.push(action);
+				break;
+			}
 			case "drop_index":
 				if (!change.name) continue;
 				migrations.push({
@@ -7752,6 +7773,15 @@ export default testManifest;
 					schemaContract: config.schemaContract
 				}));
 				const initOrder = ObjectRegistry.getInitializationOrder();
+				const engine = resolveDDLPreviewEngine(dbType);
+				const schemas = Object.values(ObjectRegistry.getAllSchemasAsDefinitions());
+				const preflightTables = new Set(schemas.map((schema) => schema.tableName));
+				const missingPreflightTables = [...new Set(initOrder.flatMap((className) => {
+					const tableName = ObjectRegistry.getTableName(className);
+					return tableName && !preflightTables.has(tableName) ? [tableName] : [];
+				}))].sort();
+				if (missingPreflightTables.length > 0) throw new Error(`Cannot safely preflight database setup because structured schema definitions are missing for: ${missingPreflightTables.join(", ")}. Rebuild the package manifests before running db:setup.`);
+				const plan = planForeignKeyCreation(schemas, engine);
 				if (options.verbose) {
 					console.log("📋 Initialization order (respecting dependencies):");
 					for (let i = 0; i < initOrder.length; i++) {
@@ -7764,25 +7794,17 @@ export default testManifest;
 				}
 				if (options["dry-run"]) {
 					console.log("📋 SQL Preview (not executed):\n");
-					const { generateSchema } = await import("@happyvertical/smrt-core/schema/utils");
-					for (const className of initOrder) {
-						const registered = ObjectRegistry.getClass(className);
-						if (!registered) continue;
-						const tableStrategy = ObjectRegistry.getTableStrategy(className);
-						const stiBase = ObjectRegistry.getSTIBase(className);
-						const qualifiedClassName = registered.qualifiedName ?? registered.name ?? className;
-						if (tableStrategy === "sti" && !!stiBase && stiBase !== qualifiedClassName && stiBase !== className) {
-							console.log(`-- Table: ${className} (Base: ${stiBase}, Strategy: STI)`);
-							console.log(`-- Shares table with ${stiBase} (STI child)\n`);
-							continue;
-						}
-						const schema = await generateSchema(registered.constructor, void 0, { engine: resolveDDLPreviewEngine(dbType) });
-						if (schema && schema.trim() !== "") {
-							const tableName = ObjectRegistry.getTableName(className);
-							console.log(`-- Table: ${tableName} (Class: ${className}, Strategy: ${tableStrategy === "sti" ? "STI" : "CTI"})`);
-							console.log(schema);
-							console.log();
-						}
+					for (const schema of plan.schemas) {
+						const ddl = generateDDLForEngine(schema, engine);
+						console.log(`-- Table: ${schema.tableName}`);
+						console.log(ddl.createTable);
+						for (const statement of [...ddl.indexes, ...ddl.triggers]) console.log(statement);
+						console.log();
+					}
+					if (plan.deferredStatements.length > 0) {
+						console.log("-- Deferred foreign-key constraints");
+						for (const statement of plan.deferredStatements) console.log(statement);
+						console.log();
 					}
 					console.log("✅ Dry-run complete (no changes made)\n");
 					return;
@@ -7814,23 +7836,42 @@ export default testManifest;
 					}
 					console.log("\n🗑️  Dropping existing tables...\n");
 					const dropOrder = [...initOrder].reverse();
-					for (const className of dropOrder) {
-						const tableName = ObjectRegistry.getTableName(className);
-						if (!tableName) continue;
-						try {
-							await db.execute`DROP TABLE IF EXISTS ${tableName}`;
-							console.log(`  ✓ Dropped ${tableName}`);
-						} catch (error) {
-							if (options.verbose) console.log(`  ⚠️  Could not drop ${tableName}: ${error}`);
+					const dropEngine = resolveDDLPreviewEngine(dbType);
+					if (dropEngine === "sqlite") await db.query("PRAGMA foreign_keys = OFF");
+					try {
+						for (const className of dropOrder) {
+							const tableName = ObjectRegistry.getTableName(className);
+							if (!tableName) continue;
+							try {
+								const cascade = dropEngine === "postgres" ? " CASCADE" : "";
+								await db.query(`DROP TABLE IF EXISTS ${quoteIdentifier(tableName)}${cascade}`);
+								console.log(`  ✓ Dropped ${tableName}`);
+							} catch (error) {
+								if (options.verbose) console.log(`  ⚠️  Could not drop ${tableName}: ${error}`);
+								throw new Error(`Refusing to continue after failing to drop ${tableName}; dependency or foreign-key constraints may still be active.`, { cause: error });
+							}
 						}
+					} finally {
+						if (dropEngine === "sqlite") await db.query("PRAGMA foreign_keys = ON");
 					}
 					console.log();
 				}
 				console.log("🔨 Creating tables...\n");
-				const { ensureSchema } = await import("@happyvertical/smrt-core/schema/utils");
+				const { createSchemaManager } = await import("@happyvertical/smrt-core/schema");
+				const schemaManager = createSchemaManager(db, {
+					engine,
+					skipTriggers: typeof db.exportTable === "function"
+				});
+				try {
+					await schemaManager.ensureTables(schemas);
+				} catch (error) {
+					console.error(`  ✗ Schema creation failed: ${error}`);
+					if (options.verbose && error instanceof Error && error.stack) console.error(`\n${error.stack}\n`);
+					throw new Error("Refusing to report database setup success after schema creation failed.", { cause: error });
+				}
 				let tablesCreated = 0;
 				let tablesSkipped = 0;
-				for (const className of initOrder) try {
+				for (const className of initOrder) {
 					const tableStrategy = ObjectRegistry.getTableStrategy(className);
 					const stiBase = ObjectRegistry.getSTIBase(className);
 					const registered = ObjectRegistry.getClass(className);
@@ -7840,14 +7881,10 @@ export default testManifest;
 						if (options.verbose) console.log(`  ⊙ ${className} (shares table with ${stiBase})`);
 						continue;
 					}
-					await ensureSchema(db, className);
 					const tableName = ObjectRegistry.getTableName(className);
 					const fieldCount = ObjectRegistry.getFields(className)?.size || 0;
 					console.log(`  ✓ ${tableName} (${fieldCount} columns)`);
 					tablesCreated++;
-				} catch (error) {
-					console.error(`  ✗ ${className}: ${error}`);
-					if (options.verbose && error instanceof Error && error.stack) console.error(`\n${error.stack}\n`);
 				}
 				console.log();
 				if (tablesSkipped > 0) {
@@ -8230,16 +8267,29 @@ export default testManifest;
 					relaxColumns: Boolean(options["relax-columns"]),
 					postgresTimestampMigration
 				}).compare(manifestSchemas);
+				const engine = tracker.getEngine();
+				const tablePlan = planForeignKeyCreation(diff.added_tables, engine);
+				const plannedTableDDL = new Map(tablePlan.schemas.map((schema) => [schema.tableName, generateDDLForEngine(schema, engine)]));
+				const deferredForeignKeyMigrations = tablePlan.deferredStatements.map((statement) => {
+					const parsed = statement.match(/^ALTER TABLE\s+"((?:[^"]|"")+)"\s+ADD\s+CONSTRAINT\s+"((?:[^"]|"")+)"/i);
+					const unquote = (value, fallback) => value ? value.replace(/""/g, "\"") : fallback;
+					return {
+						type: "add_foreign_key",
+						tableName: unquote(parsed?.[1], "deferred_cycle"),
+						className: unquote(parsed?.[2], "deferred cycle constraint"),
+						sql: statement
+					};
+				});
 				const getClassForTable = (tableName) => {
 					for (const className of initOrder) if (ObjectRegistry.getTableName(className) === tableName) return className;
 					return tableName;
 				};
 				if (diff.added_tables.length > 0 && isDryRun) {
-					for (const schema of diff.added_tables) {
+					for (const schema of tablePlan.schemas) {
 						const className = getClassForTable(schema.tableName);
 						const fields = Object.keys(schema.columns).length;
 						console.log(`  📦 ${schema.tableName} (${className}): Would create table (${fields} columns)`);
-						if (options.verbose && schema.ddl) console.log(`     ${schema.ddl}`);
+						if (options.verbose) console.log(`     ${plannedTableDDL.get(schema.tableName)?.createTable}`);
 					}
 					console.log();
 				}
@@ -8247,14 +8297,26 @@ export default testManifest;
 				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] : [];
-				})]);
+				assertForceMigrationTargetsExist(forceSelection.forceMigrations, [
+					...diff.added_tables.map((schema) => `create_table_${schema.tableName}`),
+					...migrations.flatMap((migration) => {
+						const migrationName = getSyntheticMigrationNameForAction(migration);
+						return migrationName ? [migrationName] : [];
+					}),
+					...deferredForeignKeyMigrations.flatMap((migration) => {
+						const migrationName = getSyntheticMigrationNameForAction(migration);
+						return migrationName ? [migrationName] : [];
+					})
+				]);
 				console.log();
 				if (manualInterventions.length > 0) {
 					console.log("⚠️  Schema drift detected that requires manual intervention:\n");
 					for (const change of manualInterventions) {
+						if (change.type === "add_foreign_key") {
+							console.log(`   ${change.tableName}: ${change.advisory?.message ?? change.sql?.replace(/^--\s*/, "") ?? "foreign-key constraint requires manual repair"}`);
+							for (const sql of change.advisory?.suggestedSql ?? []) console.log(`      ${sql}`);
+							continue;
+						}
 						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.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}`);
@@ -8284,6 +8346,7 @@ export default testManifest;
 						}
 						const columnMigrations = migrations.filter((m) => m.type === "add_column");
 						const indexMigrations = migrations.filter((m) => m.type === "add_index");
+						const foreignKeyMigrations = migrations.filter((m) => m.type === "add_foreign_key");
 						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");
@@ -8312,7 +8375,21 @@ export default testManifest;
 							for (const m of indexMigrations) console.log(`     ${m.index?.name} on ${m.tableName}`);
 							console.log();
 						}
+						if (foreignKeyMigrations.length > 0) {
+							console.log(`  🔗 Foreign-key constraints to add: ${foreignKeyMigrations.length}`);
+							for (const m of foreignKeyMigrations) console.log(`     ${m.tableName}`);
+							console.log();
+						}
 						console.log("  SQL Statements:\n");
+						for (const schema of tablePlan.schemas) {
+							const ddl = plannedTableDDL.get(schema.tableName);
+							if (!ddl) continue;
+							for (const sql of [
+								ddl.createTable,
+								...ddl.indexes,
+								...ddl.triggers
+							]) console.log(`    ${sql}`);
+						}
 						for (const migration of systemTimestampPreview) {
 							const terminator = migration.sql.trimEnd().endsWith(";") ? "" : ";";
 							console.log(`    ${migration.sql}${terminator}`);
@@ -8321,6 +8398,7 @@ export default testManifest;
 							const sqlStatements = m.sqlStatements ?? (m.sql ? [m.sql] : []);
 							for (const sql of sqlStatements) console.log(`    ${sql};`);
 						}
+						for (const sql of tablePlan.deferredStatements) console.log(`    ${sql}`);
 						console.log();
 					}
 					if (!repairData) {
@@ -8333,13 +8411,13 @@ export default testManifest;
 				let skippedCount = 0;
 				let errorCount = 0;
 				let stiErrorCount = 0;
-				const schemaChangeCount = diff.added_tables.length + migrations.length;
+				const schemaChangeCount = diff.added_tables.length + migrations.length + deferredForeignKeyMigrations.length;
 				if (applySchemaMigrations && schemaChangeCount > 0) {
 					const migrationDefs = [];
 					const migrationLogs = /* @__PURE__ */ new Map();
-					const engine = tracker.getEngine();
-					for (const schema of diff.added_tables) {
-						const ddl = generateDDLForEngine(schema, engine);
+					for (const schema of tablePlan.schemas) {
+						const ddl = plannedTableDDL.get(schema.tableName);
+						if (!ddl) throw new Error(`Cannot create table ${schema.tableName}: planned DDL is unavailable.`);
 						const createTableSql = ddl.createTable || schema.ddl;
 						if (!createTableSql?.trim()) throw new Error(`Cannot create table ${schema.tableName}: schema definition has no generated DDL.`);
 						const migrationName = `create_table_${schema.tableName}`;
@@ -8357,6 +8435,18 @@ export default testManifest;
 						});
 						migrationLogs.set(migrationName, { successMessage: `Created table ${schema.tableName} (${fields} columns)` });
 					}
+					for (const migration of deferredForeignKeyMigrations) {
+						const migrationName = getSyntheticMigrationNameForAction(migration);
+						if (!migrationName) continue;
+						migrationDefs.push({
+							id: migrationName,
+							description: `Add deferred foreign-key constraint ${migration.className} on ${migration.tableName}`,
+							version: "1.0.0",
+							up: migration.sql ? [migration.sql] : [],
+							down: []
+						});
+						migrationLogs.set(migrationName, { successMessage: `Added deferred foreign-key constraint ${migration.className} on ${migration.tableName}` });
+					}
 					for (const migration of migrations) {
 						const migrationName = getSyntheticMigrationNameForAction(migration);
 						if (!migrationName) continue;
@@ -8380,11 +8470,14 @@ export default testManifest;
 						} else if (migration.type === "drop_index" && migration.indexName) {
 							migrationSql = migration.sql || "";
 							actionDesc = `Dropped index ${migration.indexName} on ${migration.tableName}`;
+						} else if (migration.type === "add_foreign_key") {
+							migrationSql = migration.sql || "";
+							actionDesc = `Added foreign-key constraint on ${migration.tableName}`;
 						} else continue;
 						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 === "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}`,
+							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}` : migration.type === "add_foreign_key" ? `Add foreign-key constraint on ${migration.tableName}` : `Add index ${migration.index?.name} on ${migration.tableName}`,
 							version: "1.0.0",
 							up: migrationSqlStatements,
 							down: []

package/dist/index.js

@@ -49,63 +49,63 @@ var _playgroundCommands = null;
 var _workbenchCommands = null;
 async function getGnodeCommands() {
 	if (!_gnodeCommands) {
-		const { gnodeCommands } = await import("./commands-BOw91sjd.js");
+		const { gnodeCommands } = await import("./commands-C1bK8bv9.js");
 		_gnodeCommands = gnodeCommands;
 	}
 	return _gnodeCommands;
 }
 async function getGitCommands() {
 	if (!_gitCommands) {
-		const { gitCommands } = await import("./commands-BOw91sjd.js");
+		const { gitCommands } = await import("./commands-C1bK8bv9.js");
 		_gitCommands = gitCommands;
 	}
 	return _gitCommands;
 }
 async function getGenerateCommands() {
 	if (!_generateCommands) {
-		const { generateCommands } = await import("./commands-BOw91sjd.js");
+		const { generateCommands } = await import("./commands-C1bK8bv9.js");
 		_generateCommands = generateCommands;
 	}
 	return _generateCommands;
 }
 async function getInitCommands() {
 	if (!_initCommands) {
-		const { initCommands } = await import("./commands-BOw91sjd.js");
+		const { initCommands } = await import("./commands-C1bK8bv9.js");
 		_initCommands = initCommands;
 	}
 	return _initCommands;
 }
 async function getUtilityCommands() {
 	if (!_utilityCommands) {
-		const { utilityCommands } = await import("./commands-BOw91sjd.js");
+		const { utilityCommands } = await import("./commands-C1bK8bv9.js");
 		_utilityCommands = utilityCommands;
 	}
 	return _utilityCommands;
 }
 async function getDispatchCommands() {
 	if (!_dispatchCommands) {
-		const { dispatchCommands } = await import("./commands-BOw91sjd.js");
+		const { dispatchCommands } = await import("./commands-C1bK8bv9.js");
 		_dispatchCommands = dispatchCommands;
 	}
 	return _dispatchCommands;
 }
 async function getDocsCommands() {
 	if (!_docsCommands) {
-		const { docsCommands } = await import("./commands-BOw91sjd.js");
+		const { docsCommands } = await import("./commands-C1bK8bv9.js");
 		_docsCommands = docsCommands;
 	}
 	return _docsCommands;
 }
 async function getPlaygroundCommands() {
 	if (!_playgroundCommands) {
-		const { playgroundCommands } = await import("./commands-BOw91sjd.js");
+		const { playgroundCommands } = await import("./commands-C1bK8bv9.js");
 		_playgroundCommands = playgroundCommands;
 	}
 	return _playgroundCommands;
 }
 async function getWorkbenchCommands() {
 	if (!_workbenchCommands) {
-		const { workbenchCommands } = await import("./commands-BOw91sjd.js");
+		const { workbenchCommands } = await import("./commands-C1bK8bv9.js");
 		_workbenchCommands = workbenchCommands;
 	}
 	return _workbenchCommands;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@happyvertical/smrt-cli",
-  "version": "0.42.6",
+  "version": "0.43.0",
   "description": "Developer CLI for SMRT framework - introspection, testing, and project management",
   "type": "module",
   "main": "./dist/index.js",
@@ -32,12 +32,12 @@
     "acorn": "^8.17.0",
     "fast-glob": "3.3.3",
     "tar": "^7.5.19",
-    "@happyvertical/smrt-config": "0.42.6",
-    "@happyvertical/smrt-agents": "0.42.6",
-    "@happyvertical/smrt-dev-mcp": "0.42.6",
-    "@happyvertical/smrt-playground": "0.42.6",
-    "@happyvertical/smrt-types": "0.42.6",
-    "@happyvertical/smrt-core": "0.42.6"
+    "@happyvertical/smrt-agents": "0.43.0",
+    "@happyvertical/smrt-config": "0.43.0",
+    "@happyvertical/smrt-core": "0.43.0",
+    "@happyvertical/smrt-playground": "0.43.0",
+    "@happyvertical/smrt-types": "0.43.0",
+    "@happyvertical/smrt-dev-mcp": "0.43.0"
   },
   "devDependencies": {
     "@types/node": "24.13.2",