@happyvertical/smrt-cli 0.46.0 → 0.47.1

package/dist/{commands-C4xB-FxS.js → commands-BiXRxejk.js}

@@ -1494,7 +1494,8 @@ async function runPostgresPermissions(options = {}, optional = false) {
 		])].sort();
 		const contract = {
 			...configured,
-			managedTables
+			managedTables,
+			managedTriggerFunctions: configured.managedTriggerFunctions ?? []
 		};
 		return {
 			skipped: false,
@@ -6361,6 +6362,56 @@ var dbDropFrameworkBaseTablesCommand = {
 	}
 };
 //#endregion
+//#region src/commands/db-migrate-agent-schedule-slugs.ts
+var dbMigrateAgentScheduleSlugsCommand = {
+	name: "db:migrate-agent-schedule-slugs",
+	description: "Backfill canonical slugs for legacy framework AgentSchedule rows after db:migrate. Requires a PostgreSQL maintenance window; it never runs schedules.",
+	aliases: ["migrate-agent-schedule-slugs", "db-migrate-schedule-slugs"],
+	args: [],
+	options: { "dry-run": {
+		type: "boolean",
+		description: "Validate legacy schedule identities without writing.",
+		default: false
+	} },
+	handler: async (_args, options) => {
+		let db;
+		try {
+			const { getPackageConfig } = await import("@happyvertical/smrt-config");
+			const { DEFAULT_CLI_CONFIG } = await import("./config-DfBo4hHU.js").then((n) => n.n);
+			const config = getPackageConfig("cli", DEFAULT_CLI_CONFIG);
+			if (!config.database?.url || config.database.url === ":memory:") throw new Error("Database configuration required for db:migrate-agent-schedule-slugs. Configure database.url in smrt.config.ts (or DATABASE_URL).");
+			const dbType = config.database.type || "sqlite";
+			if (dbType !== "postgres") throw new Error("db:migrate-agent-schedule-slugs currently supports PostgreSQL only; no changes were made.");
+			const { getDatabase } = await import("@happyvertical/sql");
+			const { AGENT_SCHEDULE_SLUG_BACKFILL, migrateAgentScheduleSlugs, planAgentScheduleSlugMigration } = await import("@happyvertical/smrt-agents");
+			db = await getDatabase({
+				type: dbType,
+				url: config.database.url
+			});
+			console.log("\n🗓️  AgentSchedule slug migration\n");
+			console.log(`✓ Connected to ${formatDatabaseDisplayUrl(dbType, config.database.url)}\n`);
+			if (options["dry-run"]) {
+				const plan = await planAgentScheduleSlugMigration(db);
+				console.log(`DRY RUN: ${plan.pending} AgentSchedule slug(s) would be backfilled; no schedules run and no changes made.\n`);
+				return;
+			}
+			const postgres = config.migrations?.postgres;
+			const result = await migrateAgentScheduleSlugs(db, {
+				backfillName: AGENT_SCHEDULE_SLUG_BACKFILL,
+				packageName: "@happyvertical/smrt-agents",
+				lockTimeout: parsePostgresTimeoutMs(postgres?.lockTimeout, 3e4),
+				statementTimeout: parsePostgresTimeoutMs(postgres?.statementTimeout, 6e4)
+			});
+			console.log(result.ran ? `✓ Backfilled ${result.updated} AgentSchedule slug(s); no schedules were run.\n` : "No schedule slug migration was needed.\n");
+		} catch (error) {
+			console.error(`\n❌ AgentSchedule slug migration failed: ${error instanceof Error ? error.message : String(error)}\n`);
+			process.exitCode = 1;
+		} finally {
+			await closeDatabaseConnection(db);
+		}
+	}
+};
+//#endregion
 //#region src/commands/db-migrate-int8.ts
 /**
 * db:migrate-int8 Command
@@ -6542,6 +6593,9 @@ function buildDeclaredUuidColumnSet(schemaDefinitions) {
 function declaredUuidKey(table, column) {
 	return `${table}|${column}`;
 }
+function renamedSourceColumns(renameSpecs) {
+	return new Set(renameSpecs.map((spec) => declaredUuidKey(spec.table, spec.from)));
+}
 /**
 * Decide which live TEXT columns to convert to native `uuid`.
 *
@@ -6670,111 +6724,35 @@ var dbMigrateUuidCommand = {
 			const isPostgres = dbType === "postgres" || /^postgres/i.test(dbUrl);
 			const runRenames = renameSpecs.length > 0;
 			const skipConvert = Boolean(options["skip-convert"]);
-			const sharedTxn = runRenames && !skipConvert && isPostgres && !dryRun;
-			let openTxn = false;
-			try {
-				if (runRenames) {
-					if (sharedTxn) {
-						await db.query("BEGIN");
-						openTxn = true;
-					}
-					await applyRenameBackfills(db, isPostgres, renameSpecs, dryRun, { ownTransaction: !sharedTxn });
-				}
-				if (skipConvert) {
-					console.log("Skipping TEXT→uuid conversion (--skip-convert).\n");
-					return;
-				}
-				if (!isPostgres) {
-					console.log(`Database type "${dbType}" has no native uuid column type that needs converting; uuid conversion is a no-op.\n`);
-					return;
-				}
-				const declaredUuid = await loadDeclaredUuidColumns();
-				if (declaredUuid.size === 0) {
-					console.log("No schema-declared UUID columns found in the loaded manifest.");
-					console.log("Skipping TEXT→uuid conversion (fail-closed). Run this command from\nthe project root so the SMRT manifest can be discovered, then re-run.\n");
-					if (openTxn && !dryRun) {
-						await db.query("COMMIT");
-						openTxn = false;
-					}
-					return;
-				}
-				const { rows: candidates } = await db.query(`SELECT table_name, column_name, (column_default IS NOT NULL) AS has_default
-             FROM information_schema.columns
-            WHERE table_schema = 'public'
-              AND data_type = 'text'
-              AND (column_name = 'id' OR column_name ~* '(_id|Id)$')
-            ORDER BY table_name, column_name`);
-				const liveColumns = [];
-				for (const row of candidates) {
-					const declared = declaredUuid.has(`${row.table_name}|${row.column_name}`);
-					let nonUuid = 0;
-					if (declared) {
-						const t = quoteIdentifier(row.table_name);
-						const c = quoteIdentifier(row.column_name);
-						const { rows } = await db.query(`SELECT count(*)::text AS n
-                 FROM ${t}
-                WHERE nullif(btrim(${c}), '') IS NOT NULL
-                  AND btrim(${c}) !~* '${UUID_RE}'`);
-						nonUuid = Number(rows[0]?.n ?? "0");
-					}
-					liveColumns.push({
-						table: row.table_name,
-						column: row.column_name,
-						hasDefault: Boolean(row.has_default),
-						nonUuid
-					});
-				}
-				const { convert, skipDirtyData, skipNotDeclared } = planUuidConversions(liveColumns, declaredUuid);
-				console.log(`Found ${candidates.length} TEXT id/FK column(s): ${convert.length} convertible, ${skipDirtyData.length + skipNotDeclared.length} skipped.`);
-				if (skipDirtyData.length > 0) {
-					console.log("\nSKIP (declared UUID but data still has non-UUID values — clean these first):");
-					for (const s of skipDirtyData) console.log(`  - ${s.table}.${s.column} (${s.nonUuid} non-uuid)`);
-				}
-				if (skipNotDeclared.length > 0) {
-					console.log("\nSKIP (not declared UUID by the SMRT schema, left as TEXT):");
-					for (const s of skipNotDeclared) console.log(`  - ${s.table}.${s.column}`);
-				}
-				if (convert.length === 0) {
-					console.log("\nNothing to convert. Done.\n");
-					if (openTxn && !dryRun) {
-						await db.query("COMMIT");
-						openTxn = false;
-					}
-					return;
-				}
-				console.log(`\n${dryRun ? "DRY RUN — would run" : "Applying"} ${convert.length} conversion(s):`);
-				if (!sharedTxn && !dryRun) {
-					await db.query("BEGIN");
-					openTxn = true;
-				}
-				for (const { table, column, hasDefault } of convert) {
-					const t = quoteIdentifier(table);
-					const c = quoteIdentifier(column);
-					if (hasDefault) {
-						const dropDefault = `ALTER TABLE ${t} ALTER COLUMN ${c} DROP DEFAULT`;
-						console.log(`  ${dropDefault};`);
-						if (!dryRun) await db.query(dropDefault);
-					}
-					const alter = `ALTER TABLE ${t} ALTER COLUMN ${c} TYPE uuid USING NULLIF(btrim(${c}), '')::uuid`;
-					console.log(`  ${alter};`);
-					if (!dryRun) await db.query(alter);
-				}
-				if (!dryRun) {
-					if (openTxn) {
-						await db.query("COMMIT");
-						openTxn = false;
-					}
-					console.log(`\n✓ Converted ${convert.length} column(s) to uuid.\n`);
-				} else console.log("\nDry run complete — no changes applied.\n");
-			} catch (error) {
-				if (openTxn && !dryRun) {
-					try {
-						await db.query("ROLLBACK");
-					} catch {}
-					openTxn = false;
-				}
-				throw error;
+			const runConvert = !skipConvert && isPostgres;
+			if (skipConvert) {
+				await applyRenameOnlyBackfills(db, isPostgres, renameSpecs, dryRun);
+				console.log("Skipping TEXT→uuid conversion (--skip-convert).\n");
+				return;
+			}
+			if (!isPostgres) {
+				await applyRenameOnlyBackfills(db, isPostgres, renameSpecs, dryRun);
+				console.log(`Database type "${dbType}" has no native uuid column type that needs converting; uuid conversion is a no-op.\n`);
+				return;
+			}
+			const declaredUuid = await loadDeclaredUuidColumns();
+			if (declaredUuid.size === 0) {
+				console.log("No schema-declared UUID columns found in the loaded manifest.");
+				console.log("Skipping TEXT→uuid conversion (fail-closed). Run this command from\nthe project root so the SMRT manifest can be discovered, then re-run.\n");
+				await applyRenameOnlyBackfills(db, isPostgres, renameSpecs, dryRun);
+				return;
 			}
+			if (dryRun) {
+				await applyRenameBackfills(db, isPostgres, renameSpecs, true, { ownTransaction: false });
+				await convertPostgresUuidColumns(db, declaredUuid, true, true, renamedSourceColumns(renameSpecs), renameSpecs);
+				return;
+			}
+			if (!db.transaction) throw new Error("PostgreSQL UUID migration requires DatabaseInterface.transaction(); refusing to run unpinned DDL.");
+			if (runRenames && runConvert) await convertPostgresUuidColumns(db, declaredUuid, true, false, renamedSourceColumns(renameSpecs), renameSpecs);
+			await db.transaction(async (tx) => {
+				await applyRenameBackfills(tx, true, renameSpecs, false, { ownTransaction: false });
+				await convertPostgresUuidColumns(tx, declaredUuid, false);
+			});
 		} catch (error) {
 			console.error(`\n❌ uuid migration failed: ${error instanceof Error ? error.message : String(error)}\n`);
 			process.exitCode = 1;
@@ -6786,6 +6764,403 @@ var dbMigrateUuidCommand = {
 function nullifEmpty(isPostgres, quotedCol) {
 	return isPostgres ? `nullif(btrim(${quotedCol}), '')` : `nullif(trim(${quotedCol}), '')`;
 }
+/** Execute a rename-only PostgreSQL mutation on the transaction callback. */
+async function applyRenameOnlyBackfills(db, isPostgres, renameSpecs, dryRun) {
+	if (!isPostgres || dryRun) {
+		await applyRenameBackfills(db, isPostgres, renameSpecs, dryRun, { ownTransaction: !dryRun });
+		return;
+	}
+	if (renameSpecs.length === 0) {
+		await applyRenameBackfills(db, true, renameSpecs, false, { ownTransaction: false });
+		return;
+	}
+	if (!db.transaction) throw new Error("PostgreSQL UUID migration requires DatabaseInterface.transaction(); refusing to run unpinned DDL.");
+	await db.transaction(async (tx) => {
+		await applyRenameBackfills(tx, true, renameSpecs, false, { ownTransaction: false });
+	});
+}
+function quoteLiteral(value) {
+	return `'${value.replaceAll("'", "''")}'`;
+}
+/** PostgreSQL relation reference in the migration's fixed public schema. */
+function pgTable(table) {
+	return `${quoteIdentifier("public")}.${quoteIdentifier(table)}`;
+}
+/**
+* Convert a deliberately narrow PostgreSQL dependency component.  This is
+* intentionally catalog-driven: generated text bridges are consumer schema,
+* not SMRT manifest columns, and are never guessed from a name.
+*/
+async function convertPostgresUuidColumns(db, declaredUuid, dryRun, renderDryRun = true, excludedColumns = /* @__PURE__ */ new Set(), projectedRenames = []) {
+	const { rows: candidateRows } = await db.query(`SELECT cols.table_name, cols.column_name, cols.column_default,
+              relation.oid::text AS relation_oid, attribute.attnum AS attribute_number,
+              format_type(attribute.atttypid, attribute.atttypmod) AS type_name
+         FROM information_schema.columns cols
+         JOIN pg_namespace namespace ON namespace.nspname = cols.table_schema
+         JOIN pg_class relation ON relation.relnamespace = namespace.oid AND relation.relname = cols.table_name
+         JOIN pg_attribute attribute ON attribute.attrelid = relation.oid AND attribute.attname = cols.column_name
+        WHERE cols.table_schema = 'public' AND cols.data_type = 'text'
+        AND (column_name = 'id' OR column_name ~* '(_id|Id)$')
+      ORDER BY table_name, column_name`);
+	const liveColumns = [];
+	const defaults = /* @__PURE__ */ new Map();
+	for (const row of candidateRows) {
+		const table = String(row.table_name);
+		const column = String(row.column_name);
+		if (excludedColumns.has(declaredUuidKey(table, column))) continue;
+		let nonUuid = 0;
+		if (declaredUuid.has(declaredUuidKey(table, column))) {
+			const { rows } = await db.query(`SELECT count(*)::text AS n FROM ${pgTable(table)}
+          WHERE nullif(btrim(${quoteIdentifier(column)}), '') IS NOT NULL
+            AND btrim(${quoteIdentifier(column)}) !~* '${UUID_RE}'`);
+			nonUuid = Number(rows[0]?.n ?? 0);
+		}
+		liveColumns.push({
+			table,
+			column,
+			hasDefault: row.column_default != null,
+			nonUuid
+		});
+		defaults.set(declaredUuidKey(table, column), row.column_default == null ? null : String(row.column_default));
+	}
+	for (const spec of projectedRenames) {
+		const destination = liveColumns.find((column) => column.table === spec.table && column.column === spec.to);
+		if (!destination || !declaredUuid.has(declaredUuidKey(spec.table, spec.to))) continue;
+		const { rows: source } = await db.query(`SELECT 1 FROM information_schema.columns
+        WHERE table_schema = 'public'
+          AND table_name = ${quoteLiteral(spec.table)}
+          AND column_name = ${quoteLiteral(spec.from)}`);
+		if (source.length === 0) continue;
+		const { rows } = await db.query(`SELECT count(*)::text AS n FROM ${pgTable(spec.table)}
+        WHERE ${nullifEmpty(true, quoteIdentifier(spec.from))} IS NOT NULL
+          AND ${quoteIdentifier(spec.to)} IS NULL
+          AND btrim(${quoteIdentifier(spec.from)}) !~* '${UUID_RE}'`);
+		destination.nonUuid += Number(rows[0]?.n ?? 0);
+	}
+	const { convert, skipDirtyData, skipNotDeclared } = planUuidConversions(liveColumns, declaredUuid);
+	console.log(`Found ${candidateRows.length} TEXT id/FK column(s): ${convert.length} convertible, ${skipDirtyData.length + skipNotDeclared.length} skipped.`);
+	for (const item of skipDirtyData) console.log(`  SKIP ${item.table}.${item.column}: ${item.nonUuid} non-uuid value(s)`);
+	for (const item of skipNotDeclared) console.log(`  SKIP ${item.table}.${item.column}: not schema-declared UUID`);
+	if (convert.length === 0) {
+		console.log("\nNothing to convert. Done.\n");
+		return;
+	}
+	const columns = convert.map((column) => ({
+		...column,
+		defaultExpression: defaults.get(declaredUuidKey(column.table, column.column)) ?? null,
+		relationOid: String(candidateRows.find((row) => String(row.table_name) === column.table && String(row.column_name) === column.column)?.relation_oid),
+		attributeNumber: Number(candidateRows.find((row) => String(row.table_name) === column.table && String(row.column_name) === column.column)?.attribute_number),
+		typeName: String(candidateRows.find((row) => String(row.table_name) === column.table && String(row.column_name) === column.column)?.type_name)
+	}));
+	await assertSupportedSourceColumns(db, columns);
+	const bridges = await snapshotGeneratedBridges(db, columns);
+	const foreignKeys = await snapshotForeignKeys(db, columns, bridges);
+	await assertSupportedBridgeDependencies(db, bridges, foreignKeys);
+	const tables = [.../* @__PURE__ */ new Set([
+		...columns.map((column) => column.table),
+		...bridges.map((bridge) => bridge.table),
+		...foreignKeys.map((foreignKey) => foreignKey.table)
+	])].sort();
+	if (dryRun) {
+		if (!renderDryRun) return;
+		console.log(`\nDRY RUN — dependency plan for ${columns.length} conversion(s):`);
+		for (const table of tables) console.log(`  LOCK TABLE ${pgTable(table)} IN ACCESS EXCLUSIVE MODE;`);
+		renderUuidConversionSql(columns, bridges, foreignKeys);
+		console.log("\nDry run complete — no changes applied.\n");
+		return;
+	}
+	for (const table of tables) await db.query(`LOCK TABLE ${pgTable(table)} IN ACCESS EXCLUSIVE MODE`);
+	await assertSupportedSourceColumns(db, columns);
+	for (const column of columns) {
+		const { rows } = await db.query(`SELECT cols.column_default, relation.oid::text AS relation_oid,
+              attribute.attnum AS attribute_number,
+              format_type(attribute.atttypid, attribute.atttypmod) AS type_name
+         FROM information_schema.columns cols
+         JOIN pg_namespace namespace ON namespace.nspname = cols.table_schema
+         JOIN pg_class relation ON relation.relnamespace = namespace.oid AND relation.relname = cols.table_name
+         JOIN pg_attribute attribute ON attribute.attrelid = relation.oid AND attribute.attname = cols.column_name
+        WHERE cols.table_schema = 'public'
+          AND cols.table_name = ${quoteLiteral(column.table)}
+          AND cols.column_name = ${quoteLiteral(column.column)}`);
+		const lockedDefault = rows[0]?.column_default == null ? null : String(rows[0].column_default);
+		const locked = rows[0];
+		if (lockedDefault !== column.defaultExpression || String(locked?.relation_oid) !== column.relationOid || Number(locked?.attribute_number) !== column.attributeNumber || String(locked?.type_name) !== column.typeName) throw new Error(`UUID source identity, type, or default changed while locks were acquired for ${column.table}.${column.column}; refusing stale migration plan. Re-run the command.`);
+	}
+	const rescannedBridges = await snapshotGeneratedBridges(db, columns);
+	const rescannedForeignKeys = await snapshotForeignKeys(db, columns, rescannedBridges);
+	await assertSupportedBridgeDependencies(db, rescannedBridges, rescannedForeignKeys);
+	if (JSON.stringify({
+		bridges,
+		foreignKeys
+	}) !== JSON.stringify({
+		bridges: rescannedBridges,
+		foreignKeys: rescannedForeignKeys
+	})) throw new Error("UUID dependency catalog changed while locks were acquired; refusing stale migration plan. Re-run the command.");
+	renderUuidConversionSql(columns, bridges, foreignKeys);
+	for (const foreignKey of foreignKeys) await db.query(`ALTER TABLE ${pgTable(foreignKey.table)} DROP CONSTRAINT ${quoteIdentifier(foreignKey.name)}`);
+	for (const bridge of bridges) await db.query(`ALTER TABLE ${pgTable(bridge.table)} DROP COLUMN ${quoteIdentifier(bridge.column)}`);
+	for (const column of columns) {
+		const table = pgTable(column.table);
+		const name = quoteIdentifier(column.column);
+		if (column.defaultExpression) await db.query(`ALTER TABLE ${table} ALTER COLUMN ${name} DROP DEFAULT`);
+		await db.query(`ALTER TABLE ${table} ALTER COLUMN ${name} TYPE uuid USING NULLIF(btrim(${name}), '')::uuid`);
+		if (column.defaultExpression) await db.query(`ALTER TABLE ${table} ALTER COLUMN ${name} SET DEFAULT (${column.defaultExpression})::uuid`);
+	}
+	for (const bridge of bridges) {
+		await db.query(`ALTER TABLE ${pgTable(bridge.table)} ADD COLUMN ${quoteIdentifier(bridge.column)} text GENERATED ALWAYS AS (${quoteIdentifier(bridge.sourceColumn)}::text) STORED`);
+		if (bridge.statisticsTarget != null && bridge.statisticsTarget !== -1) await db.query(`ALTER TABLE ${pgTable(bridge.table)} ALTER COLUMN ${quoteIdentifier(bridge.column)} SET STATISTICS ${bridge.statisticsTarget}`);
+		if (bridge.compression) await db.query(`ALTER TABLE ${pgTable(bridge.table)} ALTER COLUMN ${quoteIdentifier(bridge.column)} SET COMPRESSION ${bridge.compression === "l" ? "lz4" : "pglz"}`);
+	}
+	for (const { index, table } of uniqueBridgeIndexes(bridges)) {
+		await db.query(index.definition);
+		if (index.comment) await db.query(`COMMENT ON INDEX ${quoteIdentifier(index.schema)}.${quoteIdentifier(index.name)} IS ${quoteLiteral(index.comment)}`);
+		if (index.clustered) await db.query(`ALTER TABLE ${pgTable(table)} CLUSTER ON ${quoteIdentifier(index.name)}`);
+		if (index.replicaIdentity) await db.query(`ALTER TABLE ${pgTable(table)} REPLICA IDENTITY USING INDEX ${quoteIdentifier(index.name)}`);
+	}
+	for (const foreignKey of foreignKeys) {
+		await db.query(`ALTER TABLE ${pgTable(foreignKey.table)} ADD CONSTRAINT ${quoteIdentifier(foreignKey.name)} ${foreignKey.definition}${foreignKey.validated ? "" : " NOT VALID"}`);
+		if (foreignKey.comment) await db.query(`COMMENT ON CONSTRAINT ${quoteIdentifier(foreignKey.name)} ON ${pgTable(foreignKey.table)} IS ${quoteLiteral(foreignKey.comment)}`);
+	}
+	console.log(`\n✓ Converted ${columns.length} column(s) to uuid.\n`);
+}
+function uniqueBridgeIndexes(bridges) {
+	return [...new Map(bridges.flatMap((bridge) => bridge.indexDefinitions.map((index) => [index.oid, {
+		index,
+		table: bridge.table
+	}]))).values()];
+}
+async function assertSupportedSourceColumns(db, columns) {
+	for (const column of columns) {
+		const { rows: shape } = await db.query(`SELECT relispartition AS partitioned,
+              EXISTS (SELECT 1 FROM pg_inherits i WHERE i.inhrelid = c.oid OR i.inhparent = c.oid) AS inherited
+         FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE n.nspname = 'public' AND c.relname = ${quoteLiteral(column.table)} AND c.relkind = 'r'`);
+		if (shape.length !== 1 || shape[0].partitioned || shape[0].inherited) throw new Error(`Unsupported table shape for ${column.table}.${column.column}; UUID conversion supports only non-partitioned, non-inherited public tables.`);
+		const { rows: views } = await db.query(`SELECT dependent.relname AS name
+         FROM pg_depend dep
+         JOIN pg_rewrite rule ON rule.oid = dep.objid
+         JOIN pg_class dependent ON dependent.oid = rule.ev_class
+         JOIN pg_class source ON source.oid = dep.refobjid
+         JOIN pg_namespace source_ns ON source_ns.oid = source.relnamespace
+         JOIN pg_attribute source_attr ON source_attr.attrelid = source.oid AND source_attr.attnum = dep.refobjsubid
+        WHERE dep.classid = 'pg_rewrite'::regclass AND source_ns.nspname = 'public'
+          AND source.relname = ${quoteLiteral(column.table)} AND source_attr.attname = ${quoteLiteral(column.column)}`);
+		if (views.length > 0) throw new Error(`Unsupported view or rule dependency on ${column.table}.${column.column}: ${views.map((view) => String(view.name)).join(", ")}. Remove or migrate it separately before db:migrate-uuid.`);
+	}
+}
+function renderUuidConversionSql(columns, bridges, foreignKeys) {
+	for (const foreignKey of foreignKeys) console.log(`  ALTER TABLE ${pgTable(foreignKey.table)} DROP CONSTRAINT ${quoteIdentifier(foreignKey.name)};`);
+	for (const bridge of bridges) console.log(`  ALTER TABLE ${pgTable(bridge.table)} DROP COLUMN ${quoteIdentifier(bridge.column)};`);
+	for (const column of columns) {
+		const table = pgTable(column.table);
+		const name = quoteIdentifier(column.column);
+		if (column.defaultExpression) console.log(`  ALTER TABLE ${table} ALTER COLUMN ${name} DROP DEFAULT;`);
+		console.log(`  ALTER TABLE ${table} ALTER COLUMN ${name} TYPE uuid USING NULLIF(btrim(${name}), '')::uuid;`);
+		if (column.defaultExpression) console.log(`  ALTER TABLE ${table} ALTER COLUMN ${name} SET DEFAULT (${column.defaultExpression})::uuid;`);
+	}
+	for (const bridge of bridges) {
+		console.log(`  ALTER TABLE ${pgTable(bridge.table)} ADD COLUMN ${quoteIdentifier(bridge.column)} text GENERATED ALWAYS AS (${quoteIdentifier(bridge.sourceColumn)}::text) STORED;`);
+		if (bridge.statisticsTarget != null && bridge.statisticsTarget !== -1) console.log(`  ALTER TABLE ${pgTable(bridge.table)} ALTER COLUMN ${quoteIdentifier(bridge.column)} SET STATISTICS ${bridge.statisticsTarget};`);
+		if (bridge.compression) console.log(`  ALTER TABLE ${pgTable(bridge.table)} ALTER COLUMN ${quoteIdentifier(bridge.column)} SET COMPRESSION ${bridge.compression === "l" ? "lz4" : "pglz"};`);
+	}
+	for (const { index, table } of uniqueBridgeIndexes(bridges)) {
+		console.log(`  ${index.definition};`);
+		if (index.comment) console.log(`  COMMENT ON INDEX ${quoteIdentifier(index.schema)}.${quoteIdentifier(index.name)} IS ${quoteLiteral(index.comment)};`);
+		if (index.clustered) console.log(`  ALTER TABLE ${pgTable(table)} CLUSTER ON ${quoteIdentifier(index.name)};`);
+		if (index.replicaIdentity) console.log(`  ALTER TABLE ${pgTable(table)} REPLICA IDENTITY USING INDEX ${quoteIdentifier(index.name)};`);
+	}
+	for (const foreignKey of foreignKeys) {
+		console.log(`  ALTER TABLE ${pgTable(foreignKey.table)} ADD CONSTRAINT ${quoteIdentifier(foreignKey.name)} ${foreignKey.definition}${foreignKey.validated ? "" : " NOT VALID"};`);
+		if (foreignKey.comment) console.log(`  COMMENT ON CONSTRAINT ${quoteIdentifier(foreignKey.name)} ON ${pgTable(foreignKey.table)} IS ${quoteLiteral(foreignKey.comment)};`);
+	}
+}
+async function snapshotGeneratedBridges(db, columns) {
+	const requested = new Set(columns.map((column) => declaredUuidKey(column.table, column.column)));
+	const { rows } = await db.query(`SELECT generated.oid::text AS table_oid, generated_attr.attnum AS attribute_number,
+            def.oid::text AS attribute_default_oid,
+            generated.relname AS table_name, generated_attr.attname AS column_name,
+            pg_get_expr(def.adbin, def.adrelid) AS expression,
+            format_type(generated_attr.atttypid, generated_attr.atttypmod) AS type_name,
+            generated_attr.attnotnull AS not_null, generated_attr.attstorage AS storage,
+            generated_attr.attstattarget AS statistics_target,
+            generated_attr.attcompression AS compression,
+            generated_attr.attoptions AS options,
+            generated_attr.attacl IS NOT NULL AS has_acl,
+            generated_attr.attcollation <> (SELECT typcollation FROM pg_type WHERE oid = generated_attr.atttypid) AS nondefault_collation,
+            col_description(generated_attr.attrelid, generated_attr.attnum) AS column_comment,
+            generated.relispartition AS partitioned,
+            EXISTS (SELECT 1 FROM pg_inherits i WHERE i.inhrelid = generated.oid OR i.inhparent = generated.oid) AS inherited
+       FROM pg_attrdef def
+       JOIN pg_class generated ON generated.oid = def.adrelid
+       JOIN pg_namespace generated_ns ON generated_ns.oid = generated.relnamespace
+       JOIN pg_attribute generated_attr ON generated_attr.attrelid = generated.oid AND generated_attr.attnum = def.adnum
+      WHERE generated_ns.nspname = 'public'
+        AND generated.relkind = 'r' AND generated_attr.attgenerated = 's'`);
+	const bridges = [];
+	for (const row of rows) {
+		const bridgeTable = String(row.table_name);
+		const bridgeColumn = String(row.column_name);
+		const expression = String(row.expression).replaceAll(" ", "");
+		const sourceColumn = expression.match(/^\(?([a-zA-Z_][a-zA-Z0-9_$]*)\)?(?:::text)?$/)?.[1];
+		if (!sourceColumn) {
+			const sourceColumns = columns.filter((column) => column.table === bridgeTable);
+			if (sourceColumns.length > 0 && await generatedColumnDependsOn(db, String(row.attribute_default_oid), String(row.table_oid), sourceColumns.map((column) => column.attributeNumber))) throw new Error(`Unsupported generated dependency ${bridgeTable}.${bridgeColumn}; only a plain stored TEXT id::text bridge can coexist with a converted UUID column.`);
+			continue;
+		}
+		if (!requested.has(declaredUuidKey(bridgeTable, sourceColumn))) continue;
+		const table = bridgeTable;
+		if (bridgeTable !== table || String(row.type_name) !== "text" || row.not_null || String(row.storage) !== "x" || row.options != null || row.has_acl || row.nondefault_collation || row.column_comment != null || row.partitioned || row.inherited || ![
+			"id",
+			"(id)::text",
+			`${sourceColumn}::text`,
+			`(${sourceColumn})::text`
+		].includes(expression)) throw new Error(`Unsupported generated dependency ${bridgeTable}.${bridgeColumn}; only a plain stored TEXT ${sourceColumn}::text bridge without ACLs, comments, inheritance, partitioning, or extra attributes is supported.`);
+		const { rows: nonCanonical } = await db.query(`SELECT count(*)::text AS n FROM ${pgTable(table)}
+        WHERE ${quoteIdentifier(sourceColumn)} IS NOT NULL
+          AND ${quoteIdentifier(sourceColumn)} !~ '${UUID_RE}'`);
+		if (Number(nonCanonical[0]?.n ?? 0) > 0) throw new Error(`Refusing ${table}.${sourceColumn}: its generated TEXT bridge requires canonical lower-case UUID text; normalize or remove non-canonical values before migration.`);
+		bridges.push({
+			tableOid: String(row.table_oid),
+			attributeNumber: Number(row.attribute_number),
+			attributeDefaultOid: String(row.attribute_default_oid),
+			statisticsTarget: row.statistics_target == null ? null : Number(row.statistics_target),
+			compression: String(row.compression),
+			table,
+			column: bridgeColumn,
+			sourceColumn,
+			indexDefinitions: await snapshotBridgeIndexes(db, table, bridgeColumn)
+		});
+	}
+	return bridges.sort((a, b) => `${a.table}.${a.column}`.localeCompare(`${b.table}.${b.column}`));
+}
+/** Whether a generated expression actually references a converted source attr. */
+async function generatedColumnDependsOn(db, attributeDefaultOid, tableOid, sourceAttributeNumbers) {
+	const { rows } = await db.query(`SELECT EXISTS (
+       SELECT 1 FROM pg_depend dep
+        WHERE dep.classid = 'pg_attrdef'::regclass
+          AND dep.objid = ${quoteLiteral(attributeDefaultOid)}::oid
+          AND dep.refclassid = 'pg_class'::regclass
+          AND dep.refobjid = ${quoteLiteral(tableOid)}::oid
+          AND dep.refobjsubid IN (${sourceAttributeNumbers.join(", ")})
+     ) AS depends_on_converted_column`);
+	return Boolean(rows[0]?.depends_on_converted_column);
+}
+async function snapshotBridgeIndexes(db, table, column) {
+	const { rows } = await db.query(`SELECT index_rel.oid::text AS oid, index_ns.nspname AS index_schema,
+            index_rel.relname AS index_name, pg_get_indexdef(index_rel.oid) AS definition,
+            obj_description(index_rel.oid, 'pg_class') AS comment,
+            idx.indnkeyatts AS key_count, idx.indpred IS NOT NULL AS partial,
+            idx.indexprs IS NOT NULL AS expression_index, idx.indisvalid AS valid,
+            idx.indisready AS ready, idx.indisclustered AS clustered,
+            idx.indisreplident AS replica_identity,
+            index_rel.reltablespace <> 0 AS nondefault_tablespace,
+            am.amname AS method
+       FROM pg_index idx
+       JOIN pg_class table_rel ON table_rel.oid = idx.indrelid
+       JOIN pg_namespace ns ON ns.oid = table_rel.relnamespace
+       JOIN pg_class index_rel ON index_rel.oid = idx.indexrelid
+       JOIN pg_namespace index_ns ON index_ns.oid = index_rel.relnamespace
+       JOIN pg_am am ON am.oid = index_rel.relam
+       JOIN pg_attribute attr ON attr.attrelid = table_rel.oid AND attr.attnum = ANY(idx.indkey)
+      WHERE ns.nspname = 'public' AND table_rel.relname = ${quoteLiteral(table)}
+        AND attr.attname = ${quoteLiteral(column)}
+       ORDER BY index_ns.nspname, index_rel.relname, index_rel.oid`);
+	return rows.map((row) => {
+		if (Number(row.key_count) !== 1 || row.partial || row.expression_index || !row.valid || !row.ready || row.nondefault_tablespace || row.method !== "btree") throw new Error(`Unsupported index depending on generated bridge ${table}.${column}; only one-key valid btree indexes without a custom tablespace can be reconstructed safely.`);
+		return {
+			oid: String(row.oid),
+			schema: String(row.index_schema),
+			name: String(row.index_name),
+			definition: String(row.definition),
+			comment: row.comment == null ? null : String(row.comment),
+			clustered: Boolean(row.clustered),
+			replicaIdentity: Boolean(row.replica_identity)
+		};
+	});
+}
+async function snapshotForeignKeys(db, columns, bridges) {
+	const converted = new Set(columns.map((column) => declaredUuidKey(column.table, column.column)));
+	const bridgeColumns = new Set(bridges.map((bridge) => declaredUuidKey(bridge.table, bridge.column)));
+	const { rows } = await db.query(`SELECT con.oid, child.relname AS child_table, con.conname AS name,
+            parent.relname AS parent_table, con.convalidated AS validated,
+            pg_get_constraintdef(con.oid) AS definition,
+            obj_description(con.oid, 'pg_constraint') AS comment,
+            EXISTS (
+              SELECT 1 FROM pg_trigger trigger
+               WHERE trigger.tgconstraint = con.oid
+                 AND trigger.tgenabled <> 'O'
+            ) AS nondefault_trigger_mode,
+            array_length(con.conkey, 1) AS child_keys,
+            array_length(con.confkey, 1) AS parent_keys,
+            child_attr.attname AS child_column, parent_attr.attname AS parent_column
+       FROM pg_constraint con
+       JOIN pg_class child ON child.oid = con.conrelid
+       JOIN pg_namespace child_ns ON child_ns.oid = child.relnamespace
+       JOIN pg_class parent ON parent.oid = con.confrelid
+       JOIN unnest(con.conkey) WITH ORDINALITY child_key(attnum, ord) ON true
+       JOIN unnest(con.confkey) WITH ORDINALITY parent_key(attnum, ord) ON parent_key.ord = child_key.ord
+       JOIN pg_attribute child_attr ON child_attr.attrelid = child.oid AND child_attr.attnum = child_key.attnum
+       JOIN pg_attribute parent_attr ON parent_attr.attrelid = parent.oid AND parent_attr.attnum = parent_key.attnum
+      WHERE con.contype = 'f' AND child_ns.nspname = 'public'`);
+	const participating = [];
+	for (const row of rows) {
+		const child = declaredUuidKey(String(row.child_table), String(row.child_column));
+		const parent = declaredUuidKey(String(row.parent_table), String(row.parent_column));
+		if (!converted.has(child) && !converted.has(parent) && !bridgeColumns.has(child) && !bridgeColumns.has(parent)) continue;
+		if (Number(row.child_keys) !== 1 || Number(row.parent_keys) !== 1) throw new Error(`Unsupported multi-column foreign key ${String(row.name)} touches UUID migration component.`);
+		const bridgeEdge = bridgeColumns.has(child) || bridgeColumns.has(parent);
+		if (bridgeEdge && (converted.has(child) || converted.has(parent))) throw new Error(`Foreign key ${String(row.name)} mixes a UUID-converted endpoint with a retained TEXT generated bridge; refusing incompatible recreation.`);
+		if (!bridgeEdge && (!converted.has(child) || !converted.has(parent))) throw new Error(`Foreign key ${String(row.name)} crosses a UUID conversion component boundary (${child} → ${parent}); declare both endpoints UUID or migrate it separately.`);
+		if (row.nondefault_trigger_mode) throw new Error(`Unsupported foreign key ${String(row.name)} has nondefault PostgreSQL trigger enforcement; refusing to recreate it with weaker semantics.`);
+		participating.push({
+			oid: String(row.oid),
+			table: String(row.child_table),
+			name: String(row.name),
+			definition: String(row.definition),
+			validated: Boolean(row.validated),
+			comment: row.comment == null ? null : String(row.comment)
+		});
+	}
+	return participating.sort((a, b) => `${a.table}.${a.name}`.localeCompare(`${b.table}.${b.name}`));
+}
+/**
+* A bridge column is dropped and rebuilt. pg_depend is the authoritative
+* catalog for every object which would be removed with it, including objects
+* whose definition does not expose the column name (expression indexes,
+* predicates, and extended statistics). Keep only dependencies we snapshot
+* and recreate exactly; fail closed for every other catalog object.
+*/
+async function assertSupportedBridgeDependencies(db, bridges, foreignKeys) {
+	const foreignKeyOids = new Set(foreignKeys.map((foreignKey) => foreignKey.oid));
+	for (const bridge of bridges) {
+		const indexOids = new Set(bridge.indexDefinitions.map((index) => index.oid));
+		const { rows } = await db.query(`SELECT dep.classid::regclass::text AS class_name,
+              dep.objid::text AS object_oid,
+              dep.objsubid AS object_subid,
+              dep.deptype,
+              coalesce(obj_class.relname, con.conname, stat.stxname, '') AS object_name
+         FROM pg_depend dep
+         LEFT JOIN pg_class obj_class
+           ON dep.classid = 'pg_class'::regclass AND obj_class.oid = dep.objid
+         LEFT JOIN pg_constraint con
+           ON dep.classid = 'pg_constraint'::regclass AND con.oid = dep.objid
+         LEFT JOIN pg_statistic_ext stat
+           ON dep.classid = 'pg_statistic_ext'::regclass AND stat.oid = dep.objid
+        WHERE dep.refclassid = 'pg_class'::regclass
+          AND dep.refobjid = ${quoteLiteral(bridge.tableOid)}::oid
+          AND dep.refobjsubid = ${bridge.attributeNumber}`);
+		for (const row of rows) {
+			const className = String(row.class_name);
+			const objectOid = String(row.object_oid);
+			const knownAttributeDefinition = className === "pg_attrdef" && objectOid === bridge.attributeDefaultOid;
+			const knownIndex = className === "pg_class" && indexOids.has(objectOid);
+			const knownForeignKey = className === "pg_constraint" && foreignKeyOids.has(objectOid);
+			if (knownAttributeDefinition || knownIndex || knownForeignKey) continue;
+			const name = row.object_name ? ` ${String(row.object_name)}` : "";
+			throw new Error(`Unsupported catalog dependency on generated bridge ${bridge.table}.${bridge.column}:${name} (${className} OID ${objectOid}, dependency ${String(row.deptype)}). Remove or migrate it separately before db:migrate-uuid.`);
+		}
+	}
+}
 /**
 * Apply the R3 rename backfills: copy `old → new` where `new` is still empty,
 * then drop `old`. Idempotent (a missing source column is skipped).
@@ -6802,7 +7177,7 @@ async function applyRenameBackfills(db, isPostgres, renameSpecs, dryRun, { ownTr
 	if (useOwnTxn) await db.query("BEGIN");
 	try {
 		for (const spec of renameSpecs) {
-			const t = quoteIdentifier(spec.table);
+			const t = isPostgres ? pgTable(spec.table) : quoteIdentifier(spec.table);
 			const from = quoteIdentifier(spec.from);
 			const to = quoteIdentifier(spec.to);
 			if (!await columnExists(db, isPostgres, spec.table, spec.from)) {
@@ -7904,14 +8279,19 @@ async function readAgentSurfaceReport(cwd) {
 					name: String(playbook.key),
 					detail: `${playbook.steps.length} step(s) · ${playbook.planes.join("+")} · ${playbook.sourceFile}`
 				})),
-				notStatic: (surface?.diagnostics ?? []).map((diagnostic) => ({
-					sourceFile: diagnostic.line ? `${diagnostic.sourceFile}:${diagnostic.line}` : String(diagnostic.sourceFile),
-					message: String(diagnostic.message)
-				}))
+				notStatic: (surface?.diagnostics ?? []).filter((diagnostic) => diagnostic.code !== "tool-name-collision").map(describeAgentSurfaceDiagnostic),
+				toolNameCollisions: (surface?.diagnostics ?? []).filter((diagnostic) => diagnostic.code === "tool-name-collision").map(describeAgentSurfaceDiagnostic)
 			};
 		} catch {}
 	}
 }
+/** Where a diagnostic points, and what it says, in one printable pair. */
+function describeAgentSurfaceDiagnostic(diagnostic) {
+	return {
+		sourceFile: diagnostic.line ? `${diagnostic.sourceFile}:${diagnostic.line}` : String(diagnostic.sourceFile),
+		message: String(diagnostic.message)
+	};
+}
 /** Render the surface report as the lines `smrt doctor` prints. */
 function renderAgentSurfaceReport(report) {
 	if (!report) return ["  ⚠️  No knowledge artifact found — run a build to emit the agent surface"];
@@ -7927,6 +8307,10 @@ function renderAgentSurfaceReport(report) {
 		lines.push(`  ⚠️  Not statically emittable: ${report.notStatic.length}`);
 		for (const entry of report.notStatic) lines.push(`    - ${entry.sourceFile}: ${entry.message}`);
 	}
+	if (report.toolNameCollisions.length > 0) {
+		lines.push(`  ⚠️  Tool name also claimed: ${report.toolNameCollisions.length}`);
+		for (const entry of report.toolNameCollisions) lines.push(`    - ${entry.sourceFile}: ${entry.message}`);
+	}
 	return lines;
 }
 /**
@@ -9265,6 +9649,7 @@ export default testManifest;
 			if (agentSurfaceReport) {
 				check(`${agentSurfaceReport.modelTools.length + agentSurfaceReport.intents.length + agentSurfaceReport.playbooks.length} agent-addressable operation(s) reported`, true);
 				if (agentSurfaceReport.notStatic.length > 0) check("Agent-surface declarations are all static", false, void 0, `${agentSurfaceReport.notStatic.length} declaration(s) could not be read statically and were excluded — use useWebMcpTool for a computed tool set`);
+				if (agentSurfaceReport.toolNameCollisions.length > 0) check("Declared intents own their WebMCP tool names", false, void 0, `${agentSurfaceReport.toolNameCollisions.length} intent(s) derive a tool name a generated or fixed UI tool also claims — namespace the generated tools, reprefix the UI tools, or rename the intent; each message says the runtime condition it assumes`);
 			} else check("Agent surface reported", false, void 0, "No knowledge artifact — run a build first");
 			console.log();
 			console.log("🏃 Runtime\n");
@@ -9343,6 +9728,7 @@ export default testManifest;
 	"db:generate": dbGenerateCommand,
 	"db:migrate-uuid": dbMigrateUuidCommand,
 	"db:migrate-int8": dbMigrateInt8Command,
+	"db:migrate-agent-schedule-slugs": dbMigrateAgentScheduleSlugsCommand,
 	"db:drop-framework-base-tables": dbDropFrameworkBaseTablesCommand,
 	"db:prune": dbPruneCommand,
 	"db:permissions": dbPermissionsCommand,

package/dist/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@happyvertical/smrt-cli",
-  "version": "0.46.0",
+  "version": "0.47.1",
   "description": "Developer CLI for SMRT framework - introspection, testing, and project management",
   "type": "module",
   "main": "./dist/index.js",
@@ -24,20 +24,20 @@
     }
   },
   "dependencies": {
-    "@happyvertical/ai": "^0.89.4",
-    "@happyvertical/files": "^0.89.4",
-    "@happyvertical/logger": "^0.89.4",
-    "@happyvertical/sql": "^0.89.4",
-    "@happyvertical/utils": "^0.89.4",
+    "@happyvertical/ai": "^0.89.6",
+    "@happyvertical/files": "^0.89.6",
+    "@happyvertical/logger": "^0.89.6",
+    "@happyvertical/smrt-agents": "0.47.1",
+    "@happyvertical/smrt-config": "0.47.1",
+    "@happyvertical/smrt-core": "0.47.1",
+    "@happyvertical/smrt-dev-mcp": "0.47.1",
+    "@happyvertical/smrt-playground": "0.47.1",
+    "@happyvertical/smrt-types": "0.47.1",
+    "@happyvertical/sql": "^0.89.6",
+    "@happyvertical/utils": "^0.89.6",
     "acorn": "^8.17.0",
     "fast-glob": "3.3.3",
-    "tar": "^7.5.19",
-    "@happyvertical/smrt-core": "0.46.0",
-    "@happyvertical/smrt-playground": "0.46.0",
-    "@happyvertical/smrt-agents": "0.46.0",
-    "@happyvertical/smrt-types": "0.46.0",
-    "@happyvertical/smrt-config": "0.46.0",
-    "@happyvertical/smrt-dev-mcp": "0.46.0"
+    "tar": "^7.5.19"
   },
   "devDependencies": {
     "@types/node": "24.13.2",