@happyvertical/smrt-cli 0.47.2 → 0.49.0

package/AGENTS.md

@@ -11,9 +11,10 @@ smrt doctor --db             # Add the live-schema parity section (see below)
 smrt db:status               # Pending schema changes + failed migration classification
 smrt db:status --parity      # Same, plus live-schema parity (see below)
 smrt db:orphans              # agents/db-orphans.md
-smrt db:migrate              # Apply migrations
+smrt db:migrate              # agents/type-drift.md
 smrt db:migrate --postgres-safe # PostgreSQL concurrent-index mode (see below)
 smrt db:migrate --force-migration <exact-id> [--force-migration <exact-id>...] # Force exact generated migrations in one atomic batch
+smrt db:migrate --apply-unblocked / --null-orphans # agents/db-migrate-partial-apply.md
 smrt db:migrate-uuid         # Convert schema-declared UUID text columns after data remap
 smrt db:migrate-int8         # Explicitly widen pre-#2373 int4 columns after preflight
 smrt db:drop-framework-base-tables # One-time drop of the five #2644-orphaned framework-base tables
@@ -51,7 +52,8 @@ 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.
+failed probe stays manual with detector/repair SQL by default
+(agents/db-migrate-partial-apply.md).
 
 `db:migrate --dry-run` and deprecated `db:setup --dry-run` print the same
 engine-specific dependency plan used for execution, including exact table DDL
@@ -327,33 +329,33 @@ drop `includeDroppedTables` (default `false`, both call sites explicit —
 ## Architecture
 
 - **Lazy command loading**: commands loaded on-demand via dynamic import (~100ms overhead on first use)
-- **Manifest discovery**: auto-finds `.smrt/manifest.json` + scans `node_modules/@happyvertical/smrt-*`
-- **Aggregate manifest identity**: preload and schema discovery resolve package ownership per entry (`definition.packageName` before the container), so dependency objects retain their qualified registrations
+- **Manifest discovery**: finds `.smrt/manifest.json` + scans `node_modules/@happyvertical/smrt-*`
+- **Aggregate manifest identity**: preload/schema discovery resolve package ownership per entry (`definition.packageName` before the container), keeping dependency objects' qualified registrations
 - **Class loading order**: config.entryPoint → package.json exports['.'] → package.json main → `./dist/index.js`
-- **Object method exposure**: custom methods on SMRT objects auto-become CLI commands
+- **Object method exposure**: custom SMRT object methods auto-become CLI commands
 
 ## Key Files
 
-- `src/cli-generator.ts` — core dispatcher, lazy command loading, class loading
+- `src/cli-generator.ts` — core dispatcher, lazy command/class loading
 - `src/commands/` — individual command implementations
 - `src/loaders/` — class-loader, local-loader, npm-loader, git-loader, template-loader
 - `src/discovery/manifest-discovery.ts` — manifest auto-discovery
-- `src/commands/docs-claude.ts` — downstream AGENTS.md generation plus Claude compatibility alias; uses core knowledge discovery without object scanning
+- `src/commands/docs-claude.ts` — downstream AGENTS.md generation + Claude alias; no object scanning
 
 ## Gotchas
 
-- **Test mode detection**: checks `NODE_ENV=test`, `VITEST=true`, `global.it`/`describe` — could conflict with other test runners
-- **External package load failures silenced**: one package failing doesn't prevent others from loading
+- **Test mode detection**: checks `NODE_ENV=test`, `VITEST=true`, `global.it`/`describe` — may conflict with other test runners
+- **External package load failures silenced**: one package failing doesn't block others
 - **Generation command names are hyphenated**: `generate-mcp` and `generate-types` have
-  no colon alias. Only `generate-routes` and `generate-register` declare one, so
-  `smrt generate:mcp` is an unknown command (#2279).
+  no colon alias. Only `generate-routes`/`generate-register` declare one, so
+  `smrt generate:mcp` is unknown (#2279).
 - **Subcommand `--version` beats the global flag**: `parseCliArgs` in
   `@happyvertical/utils` dispatches to the built-in `version` command for a
   `--version` token anywhere in argv. `parseCliCommandArgs` rescopes that token to
   the named subcommand (`smrt generate-mcp --version 0.1.0`) and only leaves it
   global when it appears before or without a subcommand (#2279). `--help` is
   deliberately untouched.
-- **Schema history nuance**: `db:status` / `db:history` should distinguish active live drift from superseded failed generated schema repairs instead of treating all failed rows as current blockers
+- **Schema history nuance**: `db:status`/`db:history` should distinguish active live drift from superseded failed repairs, not treat every failed row as a current blocker
 - **Decorator check follows the Vite major**: doctor requires `oxc.decorator` in
   vite.config on Vite 8+ and accepts tsconfig `experimentalDecorators` only
   below it. The old unconditional tsconfig check flagged correct Vite 8 projects

package/agents/db-migrate-partial-apply.md

@@ -0,0 +1,189 @@
+# `db:migrate --apply-unblocked` and `--null-orphans` (#2748)
+
+Both are opt-in and off by default; default `db:migrate` behavior is
+unchanged either way. Implementation: `packages/cli/src/commands/
+db-migrate-actions.ts` (pure partition/planning functions) and
+`packages/cli/src/commands/utilities.ts`'s `db:migrate` handler (wiring,
+I/O). Core side: `SchemaChange.orphanBlocked` / `.orphanNullable` /
+`.engineUnsupported` (`packages/core/src/schema/types.ts`), set by the
+FK advisory branches in `compareForeignKeys()`
+(`packages/core/src/migrations/differ.ts`), and
+`renderForeignKeyAddStatements()` (`packages/core/src/schema/
+foreign-key-ddl.ts`).
+
+## `--apply-unblocked`: partial apply
+
+Today's unflagged batch already excludes every individually blocked change
+(a FK-with-orphans, a manual `type_upgrade`/`alter_column`) — those never
+leave `SchemaDiff.changes` as executable SQL, so they never enter the atomic
+tracker batch on their own. `--apply-unblocked` adds a second, opt-in
+partition on top of that: it withholds not just the blocked changes
+themselves but anything that *depends* on one, and applies everything else.
+
+**Dependency rule.** `computeBlockedColumns()` reads every manual
+intervention's blocked `table.column` identity, plus every report-only
+`type_upgrade` **advisory** (the #2608 refused uuid convergence — the only
+producer of that shape) — an advisory-only finding never enters
+`manualInterventions` (it carries no SQL) but names a live column just as
+concretely, and a dependent index/alter/drop on that column is exactly as
+unsafe as one on a manual-intervention column (review finding, #2748: the
+advisory bucket was previously excluded, so `--apply-unblocked` did not
+honor its own stated guarantee for that class of blocked type upgrade).
+`partitionUnblockedMigrations()` then withholds any `add_index` /
+`add_foreign_key` / `alter_column` / `drop_column` that reads or writes one
+of those columns:
+
+- an index on a column whose type upgrade is blocked (manual intervention
+  or report-only advisory);
+- a foreign key whose child *or* parent column is blocked (a parent column
+  mid-type-upgrade is just as unsafe to reference as the child);
+- an `alter_column`/`drop_column` on the blocked column itself.
+
+**A report-only `alter_column` advisory is deliberately excluded from that
+second loop**, even though `SchemaAdvisory` allows the type. Unlike
+`type_upgrade`, the only producer of an advisory-only `alter_column` is an
+un-opted-into relaxation (`drop_default`/`drop_not_null` when
+`--relax-columns` was not passed) — it says the live column is *stricter*
+than the manifest, not that anything about the column blocks convergence,
+and it reappears on every run regardless of `--apply-unblocked`. Blocking on
+it reproduced the exact `engineUnsupported` defect for a different shape:
+permanently withholding unrelated executable DDL on that column, worse than
+omitting the flag (review finding, #2748, second pass). A genuinely blocked
+`alter_column` — NOT NULL required with live NULLs and no default to
+backfill — carries its refusal as comment-only SQL and already reaches
+`manualInterventions` (keyed by `columnName`), so it was never affected.
+
+`add_column` and an executable `type_upgrade` never depend on another
+column's state — a new column add is self-contained, and a type upgrade is
+the fix itself — so they always apply. Everything independent goes through
+the exact same transaction/tracker path an unflagged run uses.
+
+**An `add_foreign_key` blocked only because this engine cannot express the
+constraint at all is not a column-state block.** SQLite (table rebuild
+required) and DuckDB (no `ALTER TABLE ADD CONSTRAINT`) each carry
+`engineUnsupported: true` on that advisory — distinct from a conflicting
+constraint or an incompatible-type block, which genuinely do implicate the
+column and stay blocking. `blockedColumnForAction()` excludes only the
+`engineUnsupported` case: every real differ `add_foreign_key` advisory sets
+`foreignKey`, so gating on its mere presence blocked this case too (review
+finding, #2748) and, since no rerun on that engine ever resolves it, made
+`--apply-unblocked` permanently withhold unrelated dependent DDL on that
+column — strictly worse than omitting the flag.
+
+**An orphan-blocked `add_foreign_key`'s block is a row-data condition, not
+a column-state one — an `alter_column` relaxation on that same column is
+its remediation, not something unsafe against it.** With `--relax-columns
+--apply-unblocked`, a FK child column that is physically `NOT NULL` while
+the manifest declares it nullable (with live orphan rows) stays
+orphan-blocked — `--null-orphans` can't resolve a NOT NULL child. The
+executable `DROP NOT NULL` relaxation for that same column is exactly what
+makes the block eventually resolvable (the column becomes nullable, then a
+later `--null-orphans` run can null the references). Gating that
+relaxation on the orphan block (review finding, #2748) made the run
+withhold it on every pass, so the column never became nullable, the
+orphan block never cleared, and the batch failed forever — worse than
+omitting the flag. `computeOrphanOnlyBlockedColumns()` identifies a
+`table.column` whose *only* manual-intervention block is an orphan-blocked
+FK on that column, and `partitionUnblockedMigrations()` excludes that key
+from gating an `alter_column` specifically — an index, a different foreign
+key, or a `drop_column` on that same orphan-blocked column still correctly
+stays withheld.
+
+Withheld items print under `🔒 Withheld — depends on a blocked change`, each
+naming the `table.column` it depends on and the same reason text the manual
+intervention above it carries. `--dry-run` shows the identical
+applied/withheld partition (the partition is pure and runs before the
+dry-run/apply branch splits). A rerun is a no-op for what already applied
+and repeats the same withheld list until the underlying blocker is resolved
+— nothing here is remembered between runs; the partition is recomputed from
+the live diff every time.
+
+## `--null-orphans`: opt-in orphan-FK disposition
+
+Targets one specific blocked-item shape: a foreign key `db:migrate` would
+otherwise refuse only because live child rows don't match any parent row
+(`SchemaChange.orphanBlocked`). `planOrphanDispositions()` splits manual
+interventions into nullable (a disposition is possible) and not-nullable
+(unconditional refusal) using `SchemaChange.orphanNullable` — never by
+parsing `advisory.message` text.
+
+For a nullable child column: the *exact* `UPDATE ... SET <column> = NULL
+WHERE ...` the differ already generated for that relationship
+(`advisory.suggestedSql[1]` — never re-derived, so the disposition can never
+drift from what the differ decided the safe repair is) and the `ADD
+CONSTRAINT ... NOT VALID` + `VALIDATE CONSTRAINT` pair from
+`renderForeignKeyAddStatements()` (the same helper the differ's own safe-add
+branch uses) are combined into **one** `add_foreign_key` migration action —
+`sqlStatements: [repairSql, ...addStatements]` — and applied atomically
+through the normal tracker path, not run as a separate direct query before
+it (review finding, #2748: running the UPDATE outside the batch let a later
+failure elsewhere in the same batch roll back the FK add while leaving the
+just-nulled rows committed, silently splitting one promised disposition
+into two). The resolved FK moves from `manualInterventions` into the
+executable `migrations` bucket before the `--apply-unblocked` partition
+runs, so a relationship this flag resolves is never a blocked column for
+that dependency rule. Post-apply before/after counts are only printed once
+the batch that carries this disposition has actually committed; on a full
+rollback the generic atomic-failure message already covers it — nothing in
+that batch, including this disposition, applied.
+
+**The combined migration can still be withheld by `--apply-unblocked`
+itself**, if the FK's *parent* column is separately blocked (e.g. a
+report-only `type_upgrade` advisory) — resolving out of
+`manualInterventions` only means this specific relationship's *child*-side
+orphan block is gone, not that the dependency partition can't withhold it
+for an unrelated reason. `filterUnresolvedOrphanDispositions()` drops a
+pending post-apply report entry whose exact migration action ended up
+withheld, matched by object identity (the same reference is pushed into
+both `migrations` and the pending entry) rather than by table/column, so
+the report never prints a `✓ ... resolved` line for a migration that never
+executed (review finding, #2748) — that relationship is already covered by
+the `🔒 Withheld` listing.
+
+**"Committed" is checked per disposition, not for the whole batch.** In
+PostgreSQL concurrent-index mode (`--postgres-safe` with
+`migrations.postgres.useConcurrently`), the non-index batch — including
+this disposition's combined migration — commits in its own transaction
+before any deferred `CREATE INDEX CONCURRENTLY` migrations run separately
+and non-transactionally; a later index build failure still increments
+`errorCount` even though the non-index changes already committed. Gating
+the report on `errorCount === 0` alone silently suppressed the resolution
+line for a mutation that did commit (review finding, #2748). A batch-wide
+proxy for "did the non-index phase commit" is not enough either: it can't
+tell that apart from the non-index transaction itself rolling back (recall
+finding, #2748) — both raise `errorCount`, but only one means this
+disposition's own migration applied. The report instead re-derives each
+pending disposition's synthetic migration name
+(`getSyntheticMigrationNameForAction()`, the same helper that named it when
+building the tracker batch) and checks that exact name's own `success` in
+`tracker.applyAll()`'s per-migration results — the ground truth regardless
+of what else in the batch failed — printing a caveat line only when some
+other change in the batch failed but this disposition's own migration
+still succeeded.
+
+For a `NOT NULL` child column: refuse with the same "Manual repair required"
+text `db:migrate` always prints for that case. Nulling is not a legal repair
+there, and **this flag never deletes rows** either way — the only mutating
+statement is the UPDATE that nulls references, never a DELETE.
+
+`--dry-run` prints the exact UPDATE statement plus the live orphan count
+(`orphanCountSql()` wraps the differ's read-only detector SELECT as a
+`COUNT(*)`) before applying anything; a real run reports the count before
+and after. Composes with `smrt db:orphans` (#2753, `packages/cli/agents/
+db-orphans.md`) — same probe, same repair SQL, no duplicated logic.
+
+**Fails closed on the count probe too** (review finding, #2748):
+`countOrphanRows()` throws rather than swallowing a query failure into `0`.
+An orphan-count probe that cannot run at all is exactly the "unexpected
+shape" case this flag must report and withhold on — proceeding to null data
+on an unverified count would violate the fail-closed requirement. A probe
+failure withholds that one relationship's disposition (printed, left in
+`manualInterventions`) without aborting the rest of the batch or the other
+dispositions.
+
+## Fails closed on an unexpected shape
+
+`planOrphanDispositions()` routes an orphan-blocked, nullable change to the
+refusal bucket (never guesses SQL) if it is missing its `foreignKey`
+definition or its `advisory.suggestedSql` pair — a differ-side contract
+violation, not something this disposition should paper over.

package/agents/type-drift.md

@@ -0,0 +1,53 @@
+# Float-width, timestamptz, and jsonb convergence (#2770, #2771, #2772)
+
+## Float-width drift (#2770)
+
+`db:status`/`db:diff` report float-width drift (`real` vs `double precision`)
+as `column_type_drift`, the same severity class as `legacy_integer_width`; a
+live single-precision column backed by a double-precision declaration widens
+automatically (lossless), but a double-precision live column backed by a
+single-precision declaration stays advisory-only (narrowing loses precision).
+
+## text -> timestamptz convergence (#2771)
+
+A `text` column on a table smrt itself creates, backed by a manifest
+`TIMESTAMP` (-> `TIMESTAMPTZ` on PostgreSQL) declaration, converges instead of
+staying blocked forever: `db:migrate` runs a server-side shape probe over
+every non-null value first (`packages/core/src/schema/text-cast-probe.ts`)
+and only plans the executable `ALTER COLUMN … TYPE timestamptz USING
+col::timestamptz` when every value is confirmed to parse unambiguously. A
+probe that finds an unparsable value fails closed with a masked sample
+instead of running the cast — repair the value, then rerun; the migration is
+a no-op once converged. This is independent of
+`postgresTimestampMigration.legacyTimezone`
+(`--postgres-timestamp-legacy-timezone=UTC`), which
+stays reserved for ambiguous naive wall-clock strings the probe does not
+accept. SQLite has no distinct storage for `text` vs `timestamptz`, so this
+stays advisory-only there.
+
+## text -> jsonb convergence and uuid visibility (#2772)
+
+A `text` column on a table smrt itself creates, backed by a manifest `JSON`
+(-> `jsonb` on PostgreSQL) declaration, was previously invisible to
+`db:status`/`db:diff` and had no `db:migrate` repair path (the #1335
+text/json tolerance is directional: it stays silent for the reverse pairing —
+a native `json`/`jsonb` live column backed by a text-convention manifest
+field — but this direction now runs the same shared shape probe as #2771's
+timestamptz path and converges the same way: a clean probe plans `ALTER
+COLUMN … TYPE jsonb USING col::jsonb`; a dirty probe fails closed with a
+masked sample. `db:status` also now reports an `info`-level finding for a
+declared-`uuid` structural column still backed by live `text` (previously
+silent by design), pointing at `db:migrate-uuid` — the tolerance itself is
+unchanged, only its visibility. SQLite stays advisory-only for both.
+
+## Live-only column defaults on either conversion
+
+PostgreSQL rejects `ALTER COLUMN … TYPE` outright whenever the column has
+any existing default that can't auto-cast to the target type, so both
+conversions above always `DROP DEFAULT` first when the *live* column has
+one — restoring it afterward (`SET DEFAULT`) only when the *manifest* also
+declares one. A live-only default (the manifest declares none) is the same
+"relaxation" `db:status --parity`'s default-drift finding already gates
+behind `relaxColumns`/`--relax-columns` elsewhere: without that opt-in, the
+conversion stays a fail-closed advisory naming the blocking default instead
+of executing.

package/dist/{commands-uHfUPryV.js → commands-DEHkYYWF.js}

@@ -22,8 +22,10 @@ import https from "node:https";
 import { homedir, tmpdir } from "node:os";
 import { extract } from "tar";
 import { importWorkspaceModule } from "@happyvertical/smrt-core/utils/import-workspace-module";
+import { renderForeignKeyAddStatements } from "@happyvertical/smrt-core/schema";
 import { FRAMEWORK_BASE_TABLE_NAMES, buildIntegerWidthTableStatements, collectIntegerWidthTargets, dropFrameworkBaseTables, parsePostgresTimeoutMs, planFrameworkBaseTableDrop, preflightIntegerWidthWidening, widenIntegerColumnsToBigInt } from "@happyvertical/smrt-core/migrations";
 import { buildArchitectureContext, buildKnowledgeIndex, buildReviewContext, checkKnowledgeFreshness, compactContextResult, diffKnowledgeIndex, renderFreshnessResult, renderKnowledgeIndexMarkdown } from "@happyvertical/smrt-dev-mcp/knowledge";
+import { RUNTIME_TOOLS } from "@happyvertical/smrt-dev-mcp/runtime";
 //#region src/commands/db-command-utils.ts
 var SENSITIVE_QUERY_PARAMS = /* @__PURE__ */ new Set([
 	"access_token",
@@ -733,7 +735,11 @@ function partitionSchemaChanges(changes, getClassForTable) {
 					className,
 					sql: change.sql,
 					...change.sqlStatements ? { sqlStatements: change.sqlStatements } : {},
-					advisory: change.advisory
+					advisory: change.advisory,
+					...change.foreignKey ? { foreignKey: change.foreignKey } : {},
+					...change.orphanBlocked !== void 0 ? { orphanBlocked: change.orphanBlocked } : {},
+					...change.orphanNullable !== void 0 ? { orphanNullable: change.orphanNullable } : {},
+					...change.engineUnsupported !== void 0 ? { engineUnsupported: change.engineUnsupported } : {}
 				};
 				if (isAdvisoryOnlyChangeLike(change)) manualInterventions.push(action);
 				else migrations.push(action);
@@ -861,6 +867,270 @@ function describeAdvisory(item) {
 		default: return `${item.tableName}.${item.name}: ${item.alteration ?? "alter_column"}${item.actual ? ` (live: ${item.actual})` : ""}`;
 	}
 }
+/** `table.column` identity used to key a blocked column across actions. */
+function blockedColumnKey(tableName, columnName) {
+	return `${tableName}.${columnName}`;
+}
+/**
+* Column that a manual-intervention action blocks, if any. `type_mismatch`,
+* a manual `type_upgrade`, and a manual `alter_column` each name exactly one
+* live column via `mismatch.column`; a blocked `add_foreign_key` names its
+* child column via `foreignKey.column` — unless the block reason is
+* `engineUnsupported` (this engine cannot express `ALTER TABLE ADD
+* CONSTRAINT` at all, e.g. SQLite/DuckDB): that says nothing about the
+* column's own state, no rerun on this engine ever resolves it, and
+* treating it as a blocked column would withhold unrelated dependent DDL
+* on that column permanently (review finding, #2748). That case blocks no
+* column identity and is excluded from dependency analysis.
+*/
+function blockedColumnForAction(action) {
+	if (action.type === "add_foreign_key" && action.foreignKey && !action.engineUnsupported) return blockedColumnKey(action.tableName, action.foreignKey.column);
+	const column = action.mismatch?.column ?? action.columnName ?? action.column?.name;
+	return column ? blockedColumnKey(action.tableName, column) : void 0;
+}
+/**
+* Every column a manual intervention blocks, keyed `table.column`, with the
+* human-readable reason (the action's advisory message, or a description of
+* the type mismatch) a dependent change is withheld for. `advisories`
+* includes only report-only `type_upgrade` findings (the #2608 refused
+* uuid convergence) — that shape is a genuine, permanent column-state block
+* that names a column just as concretely as a manual intervention does, so
+* omitting it let `--apply-unblocked` apply an index/alter/drop against a
+* column whose type convergence is itself blocked (review finding, #2748).
+*
+* `alter_column` advisories are deliberately excluded even though the type
+* exists on `SchemaAdvisory`: an advisory-only `alter_column` is produced
+* only by an un-opted-into relaxation (`drop_default`/`drop_not_null` when
+* `--relax-columns` was not passed) — it says the live column is *stricter*
+* than the manifest, not that the column's state blocks anything, and it
+* reappears on every run regardless of `--apply-unblocked`. Treating it as
+* a blocked column reproduced the exact defect this function's
+* `engineUnsupported` exclusion fixed for `add_foreign_key`: permanently
+* withholding unrelated executable DDL on that column (review finding,
+* #2748, second pass). A genuinely blocked `alter_column` (e.g. NOT NULL
+* required with live NULLs and no default) carries executable-looking SQL
+* as a comment and already reaches `manualInterventions` instead, where it
+* is covered by the loop above via `columnName`.
+*/
+function computeBlockedColumns(manualInterventions, advisories = []) {
+	const blocked = /* @__PURE__ */ new Map();
+	for (const action of manualInterventions) {
+		const key = blockedColumnForAction(action);
+		if (!key || blocked.has(key)) continue;
+		blocked.set(key, describeBlockedReason(action));
+	}
+	for (const advisory of advisories) {
+		if (advisory.type !== "type_upgrade") continue;
+		const key = blockedColumnKey(advisory.tableName, advisory.name);
+		if (blocked.has(key)) continue;
+		blocked.set(key, advisory.advisory.message ?? `${advisory.type} requires manual intervention`);
+	}
+	return blocked;
+}
+function describeBlockedReason(action) {
+	if (action.advisory?.message) return action.advisory.message;
+	if (action.mismatch) return `expected ${action.mismatch.expected}, found ${action.mismatch.actual}`;
+	return `${action.type} requires manual intervention`;
+}
+/**
+* `table.column` keys whose only manual-intervention block is an
+* orphan-blocked `add_foreign_key` on that same (child) column — a
+* row-data condition (existing rows don't match a parent), not a
+* column-state one. An un-opted-into `--relax-columns` relaxation on that
+* column (`DROP NOT NULL`/`DROP DEFAULT`) is not unsafe against orphan
+* rows; it is in fact the exact remediation that makes a NOT-NULL-child
+* orphan block eventually resolvable by `--null-orphans` on a later run.
+* Gating that `alter_column` on the orphan block made `--apply-unblocked
+* --relax-columns` withhold it forever — the relaxation never applies, the
+* live column never becomes nullable, the orphan block never clears, in a
+* stable non-converging loop (review finding, #2748). Every other
+* dependent shape on that column (an index, an unrelated foreign key, a
+* `drop_column`) still correctly stays gated by the orphan block; this set
+* narrows the exclusion to `alter_column` alone at the call site.
+*/
+function computeOrphanOnlyBlockedColumns(manualInterventions) {
+	const orphanOnly = /* @__PURE__ */ new Set();
+	const otherwiseBlocked = /* @__PURE__ */ new Set();
+	for (const action of manualInterventions) {
+		const key = blockedColumnForAction(action);
+		if (!key) continue;
+		if (action.type === "add_foreign_key" && action.orphanBlocked) orphanOnly.add(key);
+		else otherwiseBlocked.add(key);
+	}
+	for (const key of otherwiseBlocked) orphanOnly.delete(key);
+	return orphanOnly;
+}
+/**
+* Column(s) an executable migration action reads or writes, for dependency
+* analysis against `computeBlockedColumns()`. An `add_index` depends on
+* every indexed column; an `add_foreign_key` depends on its own child
+* column AND the parent column it references (a parent whose type upgrade
+* is blocked is just as unsafe to reference); `alter_column`/`drop_column`
+* depend on the single column they touch. `add_column`/`type_upgrade`/
+* `drop_index` never depend on another column's state — they are either the
+* fix itself or fully self-contained.
+*/
+function actionColumnDependencies(action) {
+	switch (action.type) {
+		case "add_index": return (action.index?.columns ?? []).map((columnName) => ({
+			tableName: action.tableName,
+			columnName
+		}));
+		case "add_foreign_key":
+			if (!action.foreignKey) return [];
+			return [{
+				tableName: action.tableName,
+				columnName: action.foreignKey.column
+			}, {
+				tableName: action.foreignKey.referencesTable,
+				columnName: action.foreignKey.referencesColumn
+			}];
+		case "alter_column":
+		case "drop_column": {
+			const columnName = action.columnName ?? action.column?.name;
+			return columnName ? [{
+				tableName: action.tableName,
+				columnName
+			}] : [];
+		}
+		default: return [];
+	}
+}
+/**
+* Partition executable migrations (the differ's "safe DDL" bucket) into
+* those independent of every blocked column and those that depend on one
+* (#2748's dependency rule): an index or foreign key on a column whose type
+* upgrade is blocked, or a foreign key whose orphan rows block it, stays
+* withheld; everything else is applied. Pure and order-preserving so a
+* dry-run preview and a real apply partition identically.
+*
+* A `drop_index` carries no column list of its own (a DB-side index being
+* removed; see `MigrationAction.indexName`'s doc comment), so it is never
+* itself a dependency target — EXCEPT when it is the drop half of the
+* #1165 shape-drift recreate pair (`drop_index` then `add_index` for the
+* SAME name, in that order, in the same batch). Withholding the `add_index`
+* half alone while letting its paired `drop_index` proceed would remove the
+* existing index/uniqueness enforcement with no replacement — reachable and
+* unsafe (review, #2748) — so a `drop_index` withholds together with any
+* `add_index` of the same name that this partition withheld.
+*/
+function partitionUnblockedMigrations(migrations, blockedColumns, orphanOnlyBlockedColumns = /* @__PURE__ */ new Set()) {
+	const directDependency = (action) => {
+		const dependency = actionColumnDependencies(action).find((dep) => {
+			const key = blockedColumnKey(dep.tableName, dep.columnName);
+			if (!blockedColumns.has(key)) return false;
+			if (action.type === "alter_column" && orphanOnlyBlockedColumns.has(key)) return false;
+			return true;
+		});
+		if (!dependency) return void 0;
+		const dependsOn = blockedColumnKey(dependency.tableName, dependency.columnName);
+		return {
+			dependsOn,
+			reason: blockedColumns.get(dependsOn) ?? "depends on a blocked change"
+		};
+	};
+	const withheldAddIndexDependency = /* @__PURE__ */ new Map();
+	const direct = migrations.map((action) => {
+		const dependency = directDependency(action);
+		if (dependency && action.type === "add_index" && action.index?.name) withheldAddIndexDependency.set(action.index.name, dependency);
+		return {
+			action,
+			dependency
+		};
+	});
+	const applied = [];
+	const withheld = [];
+	for (const { action, dependency } of direct) {
+		if (dependency) {
+			withheld.push({
+				action,
+				...dependency
+			});
+			continue;
+		}
+		const paired = action.type === "drop_index" && action.indexName ? withheldAddIndexDependency.get(action.indexName) : void 0;
+		if (paired) {
+			withheld.push({
+				action,
+				dependsOn: paired.dependsOn,
+				reason: `paired with the withheld rebuild of index ${action.indexName} (${paired.reason})`
+			});
+			continue;
+		}
+		applied.push(action);
+	}
+	return {
+		applied,
+		withheld
+	};
+}
+/**
+* Drop any pending post-apply report entry whose `action` reference was
+* withheld by `partitionUnblockedMigrations()` (review finding, #2748): a
+* `--null-orphans` combined null+add-FK migration can itself depend on a
+* separately blocked *parent* column and get withheld under
+* `--apply-unblocked` even though it already resolved out of
+* `manualInterventions`. Without this filter, the post-apply report printed
+* a `✓ ... resolved` line for a disposition that never executed — the same
+* relationship the `🔒 Withheld` listing (from `withheld`) already names.
+* Matches by object identity, not by table/column, since the caller pushed
+* the exact `MigrationAction` reference into both `migrations` and the
+* pending entry.
+*/
+function filterUnresolvedOrphanDispositions(pending, withheld) {
+	if (withheld.length === 0) return [...pending];
+	const withheldActions = new Set(withheld.map((item) => item.action));
+	return pending.filter((item) => !withheldActions.has(item.action));
+}
+/**
+* Split `manualInterventions` into orphan-blocked `add_foreign_key` actions
+* whose child column is nullable (an opt-in `--null-orphans` disposition can
+* null the references and proceed) and every other manual intervention,
+* including orphan-blocked FKs on a NOT NULL child column, which keep the
+* existing "Manual repair required" refusal (#2748) unconditionally — a
+* caller must never delete rows to make room for one of these.
+*
+* Reuses the differ's own rendered `advisory.suggestedSql` (detector at
+* index 0, repair at index 1) rather than re-deriving the orphan probe's
+* uuid-cast options, so the disposition always runs exactly the SQL the
+* differ already decided on.
+*/
+function planOrphanDispositions(manualInterventions) {
+	const nullable = [];
+	const notNullable = [];
+	for (const action of manualInterventions) {
+		if (action.type !== "add_foreign_key" || !action.orphanBlocked) continue;
+		if (!action.orphanNullable) {
+			notNullable.push(action);
+			continue;
+		}
+		const [detectorSql, repairSql] = action.advisory?.suggestedSql ?? [];
+		if (!action.foreignKey || !detectorSql || !repairSql) {
+			notNullable.push(action);
+			continue;
+		}
+		nullable.push({
+			action,
+			tableName: action.tableName,
+			column: action.foreignKey.column,
+			detectorSql,
+			repairSql
+		});
+	}
+	return {
+		nullable,
+		notNullable
+	};
+}
+/**
+* Wrap an orphan-probe `SELECT` (the differ's `renderForeignKeyOrphanDetector`
+* output, a bare `SELECT ... orphan_key ...` with no `LIMIT`) as a
+* `COUNT(*)` so `--null-orphans` can report before/after counts without
+* re-deriving the probe's own uuid-cast options.
+*/
+function orphanCountSql(detectorSql) {
+	return `SELECT COUNT(*) AS orphan_count FROM (${detectorSql}) AS smrt_orphan_probe`;
+}
 //#endregion
 //#region src/commands/postgres-timestamp-migration.ts
 /**
@@ -7907,6 +8177,95 @@ function renderContextMarkdown(result) {
 	return lines.join("\n");
 }
 //#endregion
+//#region src/commands/dev-runtime.ts
+/**
+* dev:runtime — client for the runtime dev-plane (#2782).
+*
+* With a running dev server that mounts the in-app plane (`--url` or
+* `SMRT_DEV_PLANE_URL`), the command calls the JSON route and prints the
+* envelope. Without one it falls back to the standalone Level 2 boot in this
+* process, so the same answer is available from a terminal either way.
+*/
+/** Parse repeatable `--arg key=value` flags; numbers/booleans are coerced. */
+function parseToolArgs(raw) {
+	const values = Array.isArray(raw) ? raw : raw ? [raw] : [];
+	const args = {};
+	for (const entry of values) {
+		const eq = entry.indexOf("=");
+		if (eq <= 0) continue;
+		const key = entry.slice(0, eq).trim();
+		const value = entry.slice(eq + 1).trim();
+		if (value === "true") args[key] = true;
+		else if (value === "false") args[key] = false;
+		else if (/^-?\d+(\.\d+)?$/.test(value)) args[key] = Number(value);
+		else if (value.includes(",")) args[key] = value.split(",").map((v) => v.trim());
+		else args[key] = value;
+	}
+	return args;
+}
+/** Call the in-app plane when a URL is configured; otherwise run locally. */
+async function runRuntimeTool(tool, args, options = {}) {
+	const url = options.url?.trim() || process.env.SMRT_DEV_PLANE_URL?.trim();
+	if (url) {
+		const token = options.token?.trim() || process.env.SMRT_DEV_MCP_TOKEN?.trim();
+		if (!token) throw new Error("A dev-plane URL is set but no token: pass --token or set SMRT_DEV_MCP_TOKEN");
+		const response = await (options.fetchImpl ?? fetch)(`${url.replace(/\/+$/, "")}/${tool}`, {
+			method: "POST",
+			headers: {
+				authorization: `Bearer ${token}`,
+				"content-type": "application/json"
+			},
+			body: JSON.stringify(args)
+		});
+		if (!response.ok) throw new Error(`dev-plane responded ${response.status} for ${tool}`);
+		return {
+			source: "dev-plane",
+			result: await response.json()
+		};
+	}
+	const local = RUNTIME_TOOLS[tool];
+	if (!local) throw new Error(`Unknown runtime tool "${tool}"; known: ${Object.keys(RUNTIME_TOOLS).join(", ")}`);
+	return {
+		source: "local",
+		result: await local(args)
+	};
+}
+var devRuntimeCommands = { "dev:runtime": {
+	name: "dev:runtime",
+	description: "Call a runtime dev-plane tool (runtime-registry, runtime-object, runtime-schema-diff, migration-status, job-health, schedule-health, dispatch-health, recent-changes, registry-drift) against a running dev server or, without one, the local Level 2 boot",
+	args: ["tool"],
+	options: {
+		url: {
+			type: "string",
+			description: "Dev-plane base URL (e.g. http://127.0.0.1:5173/api/_dev); default SMRT_DEV_PLANE_URL"
+		},
+		token: {
+			type: "string",
+			description: "Bearer token; default SMRT_DEV_MCP_TOKEN"
+		},
+		arg: {
+			type: "string",
+			multiple: true,
+			description: "Tool argument as key=value (repeatable; a,b,c becomes an array)"
+		},
+		json: {
+			type: "boolean",
+			description: "Print the raw envelope as JSON (default)",
+			default: true
+		}
+	},
+	handler: async (args, options) => {
+		const tool = args[0];
+		if (!tool) throw new Error("dev:runtime requires a tool name");
+		const { source, result } = await runRuntimeTool(tool, parseToolArgs(options.arg), {
+			url: options.url,
+			token: options.token
+		});
+		console.error(`[smrt] dev:runtime ${tool} via ${source}`);
+		console.log(JSON.stringify(result, null, 2));
+	}
+} };
+//#endregion
 //#region src/runtime-check.ts
 var SYSTEM_FIELDS = /* @__PURE__ */ new Set([
 	"context",
@@ -8488,6 +8847,40 @@ function resolveDDLPreviewEngine(dbType) {
 	}
 }
 /**
+* Run an orphan-count `SELECT COUNT(*)` (from `orphanCountSql()`) and read
+* back the count. Adapters disagree on the query-result envelope (some
+* return `{ rows }`, some a bare array), so normalize both the same way the
+* rest of the migration path does.
+*
+* Deliberately NOT best-effort: `--null-orphans` fails closed (#2748 review)
+* — if the probe itself cannot run (bad SQL shape, a permissions error, an
+* adapter that doesn't support the query), that is exactly the "unexpected
+* shape" case the flag must report and withhold on, not silently treat as
+* "zero orphans" and proceed to mutate data anyway. Callers that want the
+* disposition to abort on a probe failure should let this throw and catch
+* it themselves; there is no built-in fallback to 0.
+*/
+async function countOrphanRows(db, countSql) {
+	const result = await db.query(countSql);
+	const raw = (Array.isArray(result) ? result : result?.rows ?? [])[0]?.orphan_count;
+	const count = Number(raw);
+	if (!Number.isFinite(count)) throw new Error(`orphan-count probe returned a non-numeric count: ${JSON.stringify(raw)}`);
+	return count;
+}
+/**
+* One-line identity for a migration action withheld under
+* `--apply-unblocked`, for the withheld-changes report (#2748).
+*/
+function describeWithheldMigrationAction(action) {
+	switch (action.type) {
+		case "add_index": return `${action.tableName}: index ${action.index?.name ?? "(unnamed)"}`;
+		case "add_foreign_key": return `${action.tableName}: foreign key on ${action.foreignKey?.column ?? "(unknown column)"}`;
+		case "alter_column": return `${action.tableName}.${action.columnName ?? action.column?.name ?? "(unknown column)"}: ${action.alteration ?? "alter_column"}`;
+		case "drop_column": return `${action.tableName}.${action.columnName ?? "(unknown column)"}: drop column`;
+		default: return `${action.tableName}: ${action.type}`;
+	}
+}
+/**
 * Run the framework's deferred system-table compatibility pass after
 * `db:migrate` has created the tables it reshapes (issue #2376).
 *
@@ -9350,6 +9743,16 @@ export default testManifest;
 				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
 			},
+			"apply-unblocked": {
+				type: "boolean",
+				description: "Withhold only the executable changes that depend on a blocked item (an index or foreign key on a column whose type upgrade is blocked, a foreign key whose orphan rows block it), instead of the default of applying every executable change regardless of dependency. A withheld change is reported with the blocked column it depends on. Off by default: every executable change in the batch still applies even when other items need manual intervention -- this flag makes that dependency-unsafe subset stop applying, it does not add anything that was previously withheld.",
+				default: false
+			},
+			"null-orphans": {
+				type: "boolean",
+				description: "For a foreign key blocked only by orphan child rows: null the orphaned references when the child column is nullable, then add the foreign key. Refuses with the existing manual-repair message when the child column is NOT NULL. Never deletes rows. Off by default.",
+				default: false
+			},
 			verbose: {
 				type: "boolean",
 				description: "Show detailed output",
@@ -9511,6 +9914,57 @@ export default testManifest;
 				migrations.push(...partitionedChanges.migrations);
 				manualInterventions.push(...partitionedChanges.manualInterventions);
 				const advisories = partitionedChanges.advisories;
+				const pendingOrphanDispositions = [];
+				if (options["null-orphans"]) {
+					const { nullable: orphanDispositions } = planOrphanDispositions(manualInterventions);
+					if (orphanDispositions.length > 0) {
+						console.log(`🧹 Orphan-FK disposition (--null-orphans): ${orphanDispositions.length} relationship(s)\n`);
+						for (const item of orphanDispositions) {
+							const countSql = orphanCountSql(item.detectorSql);
+							let beforeCount;
+							try {
+								beforeCount = await countOrphanRows(db, countSql);
+							} catch (error) {
+								console.log(`   ✗ ${item.tableName}.${item.column}: orphan-count probe failed, withholding this disposition: ${error instanceof Error ? error.message : String(error)}`);
+								continue;
+							}
+							if (!item.action.foreignKey) continue;
+							if (isDryRun) {
+								console.log(`   ${item.tableName}.${item.column}: ${beforeCount} orphan reference(s)`);
+								console.log(`     ${item.repairSql};`);
+								console.log(`     → would null ${beforeCount} reference(s), then add the foreign key\n`);
+							}
+							const index = manualInterventions.indexOf(item.action);
+							if (index >= 0) manualInterventions.splice(index, 1);
+							const combinedAction = {
+								type: "add_foreign_key",
+								tableName: item.action.tableName,
+								className: item.action.className,
+								foreignKey: item.action.foreignKey,
+								sqlStatements: [item.repairSql, ...renderForeignKeyAddStatements(item.action.tableName, item.action.foreignKey)]
+							};
+							migrations.push(combinedAction);
+							if (!isDryRun) pendingOrphanDispositions.push({
+								tableName: item.tableName,
+								column: item.column,
+								countSql,
+								beforeCount,
+								action: combinedAction
+							});
+						}
+						console.log();
+					}
+				}
+				let withheldForDependency = [];
+				if (options["apply-unblocked"]) {
+					const partition = partitionUnblockedMigrations(migrations, computeBlockedColumns(manualInterventions, advisories), computeOrphanOnlyBlockedColumns(manualInterventions));
+					withheldForDependency = partition.withheld;
+					migrations.length = 0;
+					migrations.push(...partition.applied);
+					const stillPending = filterUnresolvedOrphanDispositions(pendingOrphanDispositions, withheldForDependency);
+					pendingOrphanDispositions.length = 0;
+					pendingOrphanDispositions.push(...stillPending);
+				}
 				const preForeignKeyMigrations = migrations.filter((migration) => migration.phase === "pre_foreign_key");
 				const remainingMigrations = migrations.filter((migration) => migration.phase !== "pre_foreign_key");
 				assertForceMigrationTargetsExist(forceSelection.forceMigrations, [
@@ -9540,12 +9994,17 @@ export default testManifest;
 					console.log();
 					console.log("   Manual migration required (backup, recreate, restore as needed).\n");
 				}
+				if (withheldForDependency.length > 0) {
+					console.log(`🔒 Withheld — depends on a blocked change (--apply-unblocked, ${withheldForDependency.length}):\n`);
+					for (const { action, dependsOn, reason } of withheldForDependency) console.log(`   ${describeWithheldMigrationAction(action)}: depends on ${dependsOn} (${reason})`);
+					console.log();
+				}
 				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 schemaUpToDate = migrations.length === 0 && manualInterventions.length === 0 && withheldForDependency.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) {
@@ -9637,6 +10096,7 @@ export default testManifest;
 				let skippedCount = 0;
 				let errorCount = 0;
 				let stiErrorCount = 0;
+				let migrationResults = [];
 				const schemaChangeCount = diff.added_tables.length + migrations.length + deferredForeignKeyMigrations.length;
 				if (applySchemaMigrations && schemaChangeCount > 0) {
 					const migrationDefs = [];
@@ -9746,6 +10206,7 @@ export default testManifest;
 								console.log(`  ✓ ${logInfo?.successMessage ?? result.name} (${checksum})`);
 							}
 						});
+						migrationResults = results;
 						const failed = migrationResultFailure(results);
 						if (failed) throw migrationResultError(failed);
 						successCount += results.filter((result) => result.success && result.applied !== false && result.execution_time_ms !== 0).length;
@@ -9759,6 +10220,21 @@ export default testManifest;
 						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.");
 					}
 				}
+				const succeededMigrationNames = new Set(migrationResults.filter((result) => result.success).map((result) => result.name));
+				const resolvedDispositions = pendingOrphanDispositions.filter((pending) => {
+					const migrationName = getSyntheticMigrationNameForAction(pending.action);
+					return migrationName ? succeededMigrationNames.has(migrationName) : false;
+				});
+				if (resolvedDispositions.length > 0) {
+					if (errorCount > 0) console.log("   (some changes in this batch failed; only fully-applied --null-orphans dispositions are listed below)");
+					for (const pending of resolvedDispositions) try {
+						const afterCount = await countOrphanRows(db, pending.countSql);
+						console.log(`   ✓ ${pending.tableName}.${pending.column}: nulled ${Math.max(pending.beforeCount - afterCount, 0)} orphan reference(s) (${afterCount} remaining)`);
+					} catch (error) {
+						console.log(`   ✓ ${pending.tableName}.${pending.column}: orphan references nulled and foreign key added (post-apply count unavailable: ${error instanceof Error ? error.message : String(error)})`);
+					}
+					console.log();
+				}
 				if (schemaUpToDate && !repairData) console.log(upToDateMessage);
 				if (repairData) {
 					console.log("\n🔄 Repairing STI discriminators to qualified names...\n");
@@ -9849,7 +10325,7 @@ export default testManifest;
 					} else console.log("ℹ️  No schema migrations were applied (none matched expected types)\n");
 				}
 				if (shouldFailDbMigrate({
-					manualInterventionCount: manualInterventions.length,
+					manualInterventionCount: manualInterventions.length + withheldForDependency.length,
 					tableErrorCount,
 					migrationErrorCount: errorCount,
 					stiErrorCount,
@@ -10139,6 +10615,7 @@ export default testManifest;
 	},
 	"runtime:check": runtimeCheckCommand,
 	...devKnowledgeCommands,
+	...devRuntimeCommands,
 	"db:status": dbStatusCommand,
 	"db:history": dbHistoryCommand,
 	"db:diff": dbDiffCommand,

package/dist/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@happyvertical/smrt-cli",
-  "version": "0.47.2",
+  "version": "0.49.0",
   "description": "Developer CLI for SMRT framework - introspection, testing, and project management",
   "type": "module",
   "main": "./dist/index.js",
@@ -28,12 +28,12 @@
     "@happyvertical/ai": "^0.89.6",
     "@happyvertical/files": "^0.89.6",
     "@happyvertical/logger": "^0.89.6",
-    "@happyvertical/smrt-agents": "0.47.2",
-    "@happyvertical/smrt-config": "0.47.2",
-    "@happyvertical/smrt-core": "0.47.2",
-    "@happyvertical/smrt-dev-mcp": "0.47.2",
-    "@happyvertical/smrt-playground": "0.47.2",
-    "@happyvertical/smrt-types": "0.47.2",
+    "@happyvertical/smrt-agents": "0.49.0",
+    "@happyvertical/smrt-config": "0.49.0",
+    "@happyvertical/smrt-core": "0.49.0",
+    "@happyvertical/smrt-dev-mcp": "0.49.0",
+    "@happyvertical/smrt-playground": "0.49.0",
+    "@happyvertical/smrt-types": "0.49.0",
     "@happyvertical/sql": "^0.89.6",
     "@happyvertical/utils": "^0.89.6",
     "acorn": "^8.17.0",
@@ -73,7 +73,7 @@
     "clean": "rm -rf dist",
     "dev": "npm run build:watch",
     "test": "vitest run",
-    "test:postgres": "node ../../scripts/run-with-ci-postgres.mjs -- pnpm exec vitest run src/commands/__tests__/db-migrate-uuid.test.ts src/commands/__tests__/db-migrate-force-postgres.test.ts src/commands/__tests__/sti-upgrade.test.ts",
+    "test:postgres": "node ../../scripts/run-with-ci-postgres.mjs -- pnpm exec vitest run src/commands/__tests__/db-migrate-uuid.test.ts src/commands/__tests__/db-migrate-force-postgres.test.ts src/commands/__tests__/sti-upgrade.test.ts src/commands/__tests__/db-migrate-partial-apply-postgres.test.ts",
     "test:watch": "vitest",
     "typecheck": "tsc -p tsconfig.typecheck.json",
     "cli": "tsx src/index.ts"