@prisma/orm-toolchain 8.0.0-rc.1-dev.37 → 8.0.0-rc.1-dev.39

package/dist/cli.mjs

@@ -1,46 +1,55 @@
 import { i as loadConfig } from "./exports-BZLNbtkY.mjs";
-import { F as requireLiveDatabase, I as runCommandAction, N as errorUnexpected, O as errorRuntime$1, a as errorConfigValidation$1, b as errorNoMigrations, c as errorDatabaseConnectionRequired, d as errorFileNotFound, h as errorLegendHumanOnly, j as errorTargetMigrationNotSupported, s as errorContractValidationFailed, t as CliStructuredError$1$1, u as errorDriverRequired, v as errorMigrationPackageNotFound } from "./cli-errors-C6_pH59O-CzD4SYcJ.mjs";
+import { I as requireLiveDatabase, L as runCommandAction, M as errorTargetMigrationNotSupported, O as errorRunnerFailed, P as errorUnexpected, a as errorConfigValidation$1, b as errorMigrationPlanningFailed, c as errorContractValidationFailed, d as errorDriverRequired, f as errorFileNotFound, g as errorLegendHumanOnly, k as errorRuntime$1, l as errorDatabaseConnectionRequired, o as errorConsentPlanMismatch, r as chooseAction, t as CliStructuredError$1$1, u as errorDestructiveChanges, x as errorNoMigrations, y as errorMigrationPackageNotFound } from "./cli-errors-BG6bItjG-DwdKIeGz.mjs";
 import { r as getEmittedArtifactPaths } from "./exports-BCLg4CiV-05kuwcb0.mjs";
-import { n as executeContractEmit } from "./contract-emit-Dp1pe06_-Cdpvh5DH.mjs";
+import { n as executeContractEmit } from "./contract-emit-CZQZ1i4z-p9LSGmmQ.mjs";
 import { h as renderPreviewStatement, m as previewBlockHeader } from "./terminal-ui-Cqz4LVL7-B0mcVdLy.mjs";
 import { c as spaceMigrationDirectory } from "./verify-contract-spaces-DhJTb0zM-_oh6W6lp.mjs";
-import { S as targetSupportsMigrations, f as maskConnectionUrl, n as closeQuietly, v as sanitizeErrorMessage } from "./command-helpers-kD9CO1hd-BPhnkBin.mjs";
-import { t as createContractEmitCommand } from "./contract-emit-Cpj5Qz7z-BXt3HGPC.mjs";
-import { n as executeFormat, t as createFormatCommand } from "./format-DceifGAK-BJhTdkcO.mjs";
-import { a as loadContractSpaceAggregateForCli, r as buildReadAggregate, s as refuseContractSpaceIntegrity, u as toDeclaredExtensionsFromRaw } from "./contract-space-aggregate-loader-BpdB-mHG-BiU0IUeb.mjs";
-import { t as createControlClient } from "./client-BqhVohc5-DFRVWFps.mjs";
+import { S as targetSupportsMigrations, f as maskConnectionUrl, h as readContractEnvelope, n as closeQuietly, v as sanitizeErrorMessage } from "./command-helpers-CwLvFwMB-BWwUQhlT.mjs";
+import { t as createContractEmitCommand } from "./contract-emit-BQFpcb2A-BwT9iVdb.mjs";
+import { n as executeFormat, t as createFormatCommand } from "./format-cbJY7l6v-CjMUDTAs.mjs";
+import { c as targetLabel, i as scaffoldSpecifierResolverFor, l as targetPackageName, n as dbFile, o as starterSchema, r as defaultSchemaPath, t as configFile } from "./code-templates-CSLH8721-CWRA4Lru.mjs";
+import { a as loadContractSpaceAggregateForCli, i as loadContractRawSafely, l as refusePackageCorruptionOnAggregate, r as buildReadAggregate, s as refuseContractSpaceIntegrity, u as toDeclaredExtensionsFromRaw } from "./contract-space-aggregate-loader-CoLTf3Ce-pQDru2w0.mjs";
+import { t as createControlClient } from "./client-DU9qtBxW-BjVHiKzE.mjs";
 import { a as readContractIR, o as resolveRefAdvancementFields, t as advanceRefSafely } from "./ref-advancement-DaZBzm7m-WoqnFAyr.mjs";
-import { t as mapDbInitFailure } from "./db-init-failure-XYOVL4o7-BitY_JYn.mjs";
-import { t as mapCaughtMigrationError } from "./caught-errors-BZ-9WASe-DH4DaDha.mjs";
-import { t as mapContractAtError } from "./contract-at-errors-CLFX1-Gc-MNPXDx1t.mjs";
-import { i as refuseUnknownInvariants, n as refuseMarkerOutsideGraph } from "./invariants-1L2zfc6--BpedlAbF.mjs";
-import { t as executeMigrateShowPlan } from "./migrate-show-bdXjSFgh-CQxl5yNp.mjs";
-import { n as resolveMigrationRef, t as resolveContractRef } from "./ref-resolution-D4fAdXo8-Dfaky0yw.mjs";
-import { n as migrationSpaceListEntriesFromAggregate, r as runMigrationList } from "./migration-list-W0dqabIj-Dc2NH_LY.mjs";
-import { S as toneSpans, b as renderMigrationListWithStyle, d as createToneMigrationListStyler, n as TONE_MIGRATION_GRAPH_PALETTE, v as renderMigrationGraphLegend, x as toneDrawing } from "./migration-graph-command-render-BeuEyf2B-BNH9oUB_.mjs";
-import { n as migrateShowRunListRows, r as renderMigrateShowGraph, t as mapMigrateFailure } from "./migrate-failure-Bdr3AJee-C9yNeQXy.mjs";
-import { n as looksLikePath, r as resolveAppTargetPath, t as findPackageByDirPath } from "./migration-path-target-5r1leSW5-B0EMgvEv.mjs";
-import { t as buildMigrationSpaceGraphEntries } from "./migration-graph-DmdVVJoZ-DDBKjUMz.mjs";
-import { n as renderMigrationGraphDot, r as renderMigrationGraphSections, t as buildMigrationGraphTreeSections } from "./migration-graph-sections-BWcFCOL6-_G0Wb4QR.mjs";
-import { a as sortLedgerEntries, i as serializeLedgerEntriesForJson, n as formatLedgerAppliedAt, o as styleHashTransition, t as MIGRATION_LOG_EMPTY_MESSAGE } from "./migration-log-table-DRiOnvzf-zTQBThqe.mjs";
-import { n as executeRefListCommand, r as executeRefSetCommand, t as executeRefDeleteCommand } from "./ref-CVD6j3jA-BAgpZLNM.mjs";
+import { t as mapDbInitFailure } from "./db-init-failure-BmCcHUfc-BqDxyrJE.mjs";
+import { t as resolveContractRefToSnapshot } from "./contract-snapshot-resolution-DvZvbNcZ-DHFCWe_k.mjs";
+import { t as mapCaughtMigrationError } from "./caught-errors-DLPzfzIW-CQ9BoXD-.mjs";
+import { t as mapContractAtError } from "./contract-at-errors-Dptf8RE_-B5gr04Sc.mjs";
+import { i as refuseUnknownInvariants, n as refuseMarkerOutsideGraph, r as refuseMissingInvariantPath, t as hasMigrationPath } from "./invariants-1zL5-9Mc-BCeOLxd_.mjs";
+import { t as executeMigrateShowPlan } from "./migrate-show-kVUG1xdo-bVTW8tu4.mjs";
+import { n as resolveMigrationRef, t as resolveContractRef } from "./ref-resolution-DAK4OK3x-B-8ZZc0f.mjs";
+import { n as migrationSpaceListEntriesFromAggregate, r as runMigrationList, t as listRefsByContractHash } from "./migration-list-BQTfSGbT-DoNqbNsu.mjs";
+import { C as toneSpans, S as toneDrawing, b as renderMigrationGraphSpaceTrees, d as createToneMigrationListStyler, m as indentMigrationGraphTreeBlock, n as TONE_MIGRATION_GRAPH_PALETTE, v as renderMigrationGraphLegend, x as renderMigrationListWithStyle } from "./migration-graph-command-render-h0VdTkSM-C3rPZEw1.mjs";
+import { n as migrateShowRunListRows, r as renderMigrateShowGraph, t as mapMigrateFailure } from "./migrate-failure-CKMEnA_x-ByHkYjn5.mjs";
+import { n as looksLikePath, r as resolveAppTargetPath, t as findPackageByDirPath } from "./migration-path-target-BNTSTPAc-D7dQ4K7x.mjs";
+import { t as buildMigrationSpaceGraphEntries } from "./migration-graph-B30X5398-BH3zB9Mn.mjs";
+import { n as renderMigrationGraphDot, r as renderMigrationGraphSections, t as buildMigrationGraphTreeSections } from "./migration-graph-sections-B8WSWSkJ-CyaRo0T6.mjs";
+import { a as sortLedgerEntries, i as serializeLedgerEntriesForJson, n as formatLedgerAppliedAt, o as styleHashTransition, t as MIGRATION_LOG_EMPTY_MESSAGE } from "./migration-log-table-eES9lPjv-BCFm8qJr.mjs";
+import { t as executeMigrationNewCommand } from "./migration-new-Bp5dPKnF-D-Fb6vEp.mjs";
+import { t as executeMigrationPlanCommand } from "./migration-plan-C6KrFHJT-CRkTsE7L.mjs";
+import { a as statusForMigrationHash, i as readMigrationRefs, n as deriveStatusEdgeAnnotations, r as originHashForStatus, t as appliedHashesFromLedger } from "./refs-fQLFcMoq-aTBeUU9H.mjs";
+import { n as executeRefListCommand, r as executeRefSetCommand, t as executeRefDeleteCommand } from "./ref-C8oaaeky-ColNkWpr.mjs";
+import { A as isRecognisedPnpmResolutionError, B as removeDependency, C as findStaleArtifacts, E as formatRunCommand, F as mergeTsConfig, G as validateSchemaPath, H as resolveAuthoring, I as minimalProjectReadmeMd, L as probeServerVersion, M as mergeGitattributes, N as mergeGitignore, O as formatSkillSourceUrl, P as mergePackageScripts, R as quickReferenceMd, S as errorInitWriteFailed, U as resolveProjectSkillInstallCommands, V as requiredGitattributesLines, W as resolveTarget, _ as errorInitProbeFailed, a as TsConfigParseError, b as errorInitStrictProbeWithoutProbe, d as envFileContent, g as errorInitMissingFlags, h as errorInitInvalidTsconfig, i as REQUIRED_SCRIPTS, j as legacySkillDirs, l as ensureEsmModuleType, m as errorInitInvalidManifest, n as DEFAULT_SKILL_SOURCES, o as buildCatalogWarnings, r as MIN_SERVER_VERSION, s as defaultTsConfig, t as DEFAULT_SKILL_AGENTS, u as envExampleContent, x as errorInitUserAborted, z as redactSecrets } from "./redact-secrets-kQ0KKV1u-MnVSKe-u.mjs";
+import { n as buildNextSteps, t as InitOutputSchema } from "./output-DP3woAjV-BxCr9nHA.mjs";
 import { CliStructuredError } from "@prisma/orm-framework/errors/control";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
-import { basename, dirname, join, normalize, relative, resolve } from "pathe";
-import { existsSync, unlinkSync, writeFileSync } from "node:fs";
-import { DOCS_BASE, isStructuredError } from "@prisma/orm-framework/utils/structured-error";
+import { basename, dirname, isAbsolute, join, normalize, relative, resolve } from "pathe";
+import { existsSync, mkdirSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
+import { DOCS_BASE, docsUrlFor, isStructuredError } from "@prisma/orm-framework/utils/structured-error";
 import { blindCast, castAs } from "@prisma/orm-framework/utils/casts";
-import { InternalError } from "@prisma/orm-framework/utils/internal-error";
+import { InternalError, assertNever } from "@prisma/orm-framework/utils/internal-error";
 import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { APP_SPACE_ID, createControlStack } from "@prisma/orm-framework/components/control";
+import { type } from "arktype";
 import { collectConfigIssues } from "@prisma/orm-framework/config/config-validation";
 import { tmpdir } from "node:os";
+import { detect } from "package-manager-detector/detect";
 import { printPsl } from "@prisma/orm-framework/psl-printer";
 import { defineCommand, defineCommandFamily, defineConfigSection, flag, positional } from "@prisma/cli-engine";
 import { CliStructuredError as CliStructuredError$1, notOk, ok } from "@prisma/cli-engine/protocol";
 import { pathToFileURL } from "node:url";
 import { build } from "esbuild";
-//#region ../../../1-framework/3-tooling/cli/dist/load-config-Db2bTG_C.mjs
+//#region ../../../1-framework/3-tooling/cli/dist/load-config-DWFCZvpn.mjs
 const MISSING_CONFIG_ACTION = {
 	kind: "run-command",
 	label: "Create a config file",
@@ -607,7 +616,7 @@ function perSpaceBlocks(perSpace, mode) {
 		roots: spaceNodes(perSpace, mode)
 	}, ...destructiveWarningBlocks(hasDestructive)];
 }
-function operationBlocks$1(result) {
+function operationBlocks$2(result) {
 	const perSpace = result.perSpace;
 	if (perSpace !== void 0 && perSpace.length > 0) return perSpaceBlocks(perSpace, result.mode);
 	if (result.plan.operations.length === 0) return [];
@@ -618,7 +627,7 @@ function operationBlocks$1(result) {
 	}, ...destructiveWarningBlocks(hasDestructive)];
 }
 /** The statements a database would run, printed verbatim rather than laid out. */
-function previewBlocks$1(preview) {
+function previewBlocks$2(preview) {
 	if (preview === void 0) return [];
 	const header = {
 		kind: "summary",
@@ -637,6 +646,22 @@ function previewBlocks$1(preview) {
 		lines: statements
 	}];
 }
+/**
+* What the planner flagged without refusing to plan it. Only `db update`
+* produces these — the additive-only policies cannot reach the branch.
+*/
+function plannerWarningBlocks(result) {
+	const warnings = result.warnings ?? [];
+	if (warnings.length === 0) return [];
+	return [{
+		kind: "summary",
+		status: "warn",
+		text: "Planner warnings"
+	}, {
+		kind: "list",
+		items: warnings.map((warning) => warning.summary)
+	}];
+}
 function planSummaryText(result) {
 	const operations = result.plan.operations.length;
 	const spaces = result.perSpace?.length ?? 0;
@@ -649,7 +674,7 @@ function applySummaryText(result) {
 	if (executed === 0) return `Database already matches contract${across}`;
 	return `Applied ${executed} operation(s)${across}`;
 }
-function planBlocks(result) {
+function planBlocks$1(result) {
 	const planned = result.plannedAdvanceRef;
 	return [
 		{
@@ -657,7 +682,8 @@ function planBlocks(result) {
 			status: "ok",
 			text: planSummaryText(result)
 		},
-		...operationBlocks$1(result),
+		...plannerWarningBlocks(result),
+		...operationBlocks$2(result),
 		{
 			kind: "fields",
 			rows: [{
@@ -676,7 +702,7 @@ function planBlocks(result) {
 				tone: "identifier"
 			}]
 		}],
-		...previewBlocks$1(result.plan.preview),
+		...previewBlocks$2(result.plan.preview),
 		{
 			kind: "summary",
 			status: "info",
@@ -717,7 +743,8 @@ function applyBlocks(result) {
 			status: "ok",
 			text: applySummaryText(result)
 		},
-		...operationBlocks$1(result),
+		...plannerWarningBlocks(result),
+		...operationBlocks$2(result),
 		...fallbackMarkerBlocks(result),
 		...advanced === null || advanced === void 0 ? [] : [{
 			kind: "summary",
@@ -731,7 +758,7 @@ function applyBlocks(result) {
 }
 /** What a `db init` / `db update` result looks like in human mode. */
 function migrationResultBlocks(result) {
-	return result.mode === "plan" ? planBlocks(result) : applyBlocks(result);
+	return result.mode === "plan" ? planBlocks$1(result) : applyBlocks(result);
 }
 /** Where the user goes next, as typed actions rather than trailing prose. */
 function migrationResultNextActions(result, applyCommand) {
@@ -750,6 +777,16 @@ function appMigrationsDirFor(config, cwd) {
 	return spaceMigrationDirectory(migrationsDirFor(config, cwd), APP_SPACE_ID);
 }
 /**
+* The config file an operation should anchor its project paths on. The engine
+* loads the config and hands a handler the value but not the path, and
+* `--config` is an engine flag the handler never sees, so a handler names the
+* invocation directory's file. That equals the loaded file for every
+* invocation whose config sits in the invocation directory.
+*/
+function projectConfigPathFor(cwd) {
+	return resolve(cwd, "prisma-next.config.ts");
+}
+/**
 * Where refs live. The framework keeps them under the app subspace rather than
 * at the migrations root.
 */
@@ -823,7 +860,7 @@ async function prepareMigrationRun(inputs) {
 		refsDir: appRefsDirFor(config, cwd)
 	});
 }
-function initPresentations(inputs) {
+function initPresentations$1(inputs) {
 	const { document, database, dryRun } = inputs;
 	return {
 		human: () => [{
@@ -955,7 +992,7 @@ function createDbInitCommand(createClient) {
 				severity: "verbose",
 				text: `Total time: ${document.timings.total}ms`
 			});
-			return ok(ctx.present({ data: document }, initPresentations({
+			return ok(ctx.present({ data: document }, initPresentations$1({
 				document,
 				contractPath: prepared.value.contractDisplayPath,
 				database: prepared.value.database,
@@ -1157,6 +1194,270 @@ function createDbSchemaCommand(createClient) {
 	});
 }
 const dbSchemaCommand = createDbSchemaCommand(createControlClient);
+/**
+* A `db update` failure as the CLI's structured error.
+*
+* `DESTRUCTIVE_CHANGES` is handled by the command, which asks for consent and
+* calls again; it is mapped here for the case the control API returns it from a
+* call that already carried consent, which would otherwise degrade silently.
+*
+* The `assertNever` is deliberate: a control-API failure code this does not
+* handle must stop the command rather than degrade into a generic message.
+*/
+function mapDbUpdateFailure(failure) {
+	if (failure.code === "PLANNING_FAILED") return errorMigrationPlanningFailed({ conflicts: failure.conflicts ?? [] });
+	if (failure.code === "RUNNER_FAILED") {
+		const fix = (typeof failure.meta?.["runnerErrorCode"] === "string" ? failure.meta["runnerErrorCode"] : void 0) === "MIGRATION.LEGACY_MARKER_SHAPE" ? "Legacy marker-table shape detected. Drop `prisma_contract.marker` (Postgres) or `_prisma_marker` (SQLite) and re-run `prisma-next db init` to recreate it with the current per-space schema." : "Inspect the reported conflict, reconcile schema drift if needed, then re-run `prisma-next db update`";
+		return errorRunnerFailed(failure.summary, {
+			why: failure.why ?? "Migration runner failed",
+			fix,
+			meta: {
+				...failure.meta,
+				...failure.warnings && failure.warnings.length > 0 ? { plannerWarnings: failure.warnings } : {}
+			},
+			...ifDefined("cause", failure.cause)
+		});
+	}
+	if (failure.code === "DESTRUCTIVE_CHANGES") return errorDestructiveChanges(failure.summary, {
+		...ifDefined("why", failure.why),
+		fix: "Re-run `prisma-next db update` and type the database name when asked, or pass `--no-interactive --confirm <database>` where there is nobody to ask. Use `--dry-run` to preview the operations first.",
+		...failure.destructiveChanges ? { meta: {
+			destructiveOperations: failure.destructiveChanges.destructiveOperations,
+			databaseName: failure.destructiveChanges.databaseName,
+			planHash: failure.destructiveChanges.planHash
+		} } : {}
+	});
+	if (failure.code === "CONSENT_PLAN_MISMATCH") return errorConsentPlanMismatch({
+		consentedPlanHash: failure.consentPlanMismatch?.consentedPlanHash ?? "",
+		planHash: failure.consentPlanMismatch?.planHash ?? "",
+		...ifDefined("why", failure.why)
+	});
+	const exhaustive = failure.code;
+	return assertNever(exhaustive, `Unhandled DbUpdateFailure code: ${String(exhaustive)}`);
+}
+/**
+* A token nobody can type is not consent: an empty one makes the engine's
+* type-to-confirm accept a bare Enter, and `--confirm ""` grant outright.
+*/
+function errorConsentTokenUnresolved(targetId) {
+	return new CliStructuredError$1("CLI.CONSENT_TOKEN_UNRESOLVED", "The database this run would change has no name to confirm.", {
+		why: `The connected database reports no name, and the target id "${targetId}" yields none either, so the consent prompt has nothing to ask you to type and the destructive operations cannot be authorised.`,
+		nextActions: [{
+			kind: "user-choice",
+			label: "Name the database in `db.connection` (or pass `--db <url>`) and run `prisma-next db update` again."
+		}]
+	});
+}
+/** A prompt that names nothing cannot be consented to knowingly. */
+function errorConsentOperationsMissing() {
+	return new CliStructuredError$1("CLI.CONSENT_OPERATIONS_MISSING", "The plan was refused as destructive but named no operations to confirm.", {
+		why: "The consent prompt has to list what is about to be destroyed, and the refusal carried no operations to list.",
+		nextActions: [{
+			kind: "run-command",
+			label: "Preview the plan",
+			command: "prisma-next db update --dry-run"
+		}]
+	});
+}
+/** The question the user answers before anything is dropped. */
+function destructiveConsentQuestion(operations, token) {
+	const listed = operations.map((operation) => `  - ${operation.label}`).join("\n");
+	return [`Apply ${operations.length} destructive operation(s) to ${token}? Data they remove cannot be recovered:`, listed].join("\n");
+}
+function updatePresentations(inputs) {
+	const { document, database, dryRun } = inputs;
+	return {
+		human: () => [{
+			kind: "fields",
+			rail: true,
+			rows: [
+				{
+					label: "contract",
+					value: inputs.contractPath
+				},
+				...database === void 0 ? [] : [{
+					label: "database",
+					value: database
+				}],
+				...inputs.to === void 0 ? [] : [{
+					label: "to",
+					value: inputs.to
+				}],
+				...dryRun ? [{
+					label: "mode",
+					value: "dry run"
+				}] : []
+			]
+		}, ...migrationResultBlocks(document)],
+		json: () => document,
+		next: () => migrationResultNextActions(document, "prisma-next db update")
+	};
+}
+function updateDocument(inputs) {
+	const { value } = inputs;
+	return {
+		ok: true,
+		mode: value.mode,
+		plan: {
+			targetId: inputs.targetId,
+			destination: {
+				storageHash: value.destination.storageHash,
+				...ifDefined("profileHash", value.destination.profileHash)
+			},
+			operations: value.plan.operations.map((operation) => ({
+				id: operation.id,
+				label: operation.label,
+				operationClass: operation.operationClass
+			})),
+			...ifDefined("preview", value.plan.preview)
+		},
+		...value.execution === void 0 ? {} : { execution: {
+			operationsPlanned: value.execution.operationsPlanned,
+			operationsExecuted: value.execution.operationsExecuted
+		} },
+		...value.marker === void 0 ? {} : { marker: {
+			storageHash: value.marker.storageHash,
+			...ifDefined("profileHash", value.marker.profileHash)
+		} },
+		...ifDefined("perSpace", value.perSpace),
+		...ifDefined("warnings", value.warnings),
+		advancedRef: inputs.advancedRef,
+		plannedAdvanceRef: inputs.plannedAdvanceRef,
+		summary: value.summary,
+		timings: { total: Date.now() - inputs.startedAt }
+	};
+}
+function createDbUpdateCommand(createClient) {
+	return defineOrmCommand({
+		help: {
+			summary: "Update your database schema to match your contract",
+			description: "Compares the database to the emitted contract and applies the changes that\nclose the gap, whether or not the database was bootstrapped with `db init`.\nAn operation that would destroy data is applied only with your consent: the\ncommand asks you to type the database name. A run with nobody to ask — a CI\njob, or `--no-interactive` — takes it from `--confirm <database>` instead.\nUse --dry-run to see the operations without applying them.",
+			examples: [
+				"db update",
+				"db update --dry-run",
+				"db update --no-interactive --confirm appdb",
+				"db update --to production"
+			]
+		},
+		args: { flags: {
+			db: dbFlag,
+			dryRun: flag.boolean({ brief: "Preview the planned operations without applying them" }),
+			to: flag.string({
+				brief: "Contract to update to (hash, prefix, ref name, migration dir name, or ./path)",
+				placeholder: "contract"
+			}),
+			advanceRef: flag.string({
+				brief: "Advance the named ref to the post-command contract hash",
+				placeholder: "name"
+			})
+		} },
+		needs: { config: ormConfigSection },
+		handler: async (args, ctx) => {
+			const startedAt = Date.now();
+			const prepared = await prepareMigrationRun({
+				config: ctx.config,
+				cwd: ctx.cwd,
+				db: args.flags.db,
+				commandName: "db update",
+				createClient
+			});
+			if (!prepared.ok) return notOk(prepared.failure);
+			const { client, contractPath, dbConnection, migrationsDir, refsDir } = prepared.value;
+			let contractJson = prepared.value.contractJson;
+			let snapshotContractPath = contractPath;
+			if (args.flags.to !== void 0) {
+				const resolved = await resolveContractRefToSnapshot({
+					config: ctx.config,
+					migrationsDir,
+					refInput: args.flags.to,
+					contractPathAbsolute: contractPath,
+					fallbackToEmitted: false,
+					missingBundleFlag: "--to"
+				});
+				if (!resolved.ok) return notOk(normalizeError(resolved.failure));
+				contractJson = resolved.value.contractJson;
+				snapshotContractPath = resolved.value.contractJsonPath;
+			}
+			const mode = args.flags.dryRun ? "plan" : "apply";
+			let document;
+			try {
+				await client.connect(dbConnection);
+				const update = (consent) => client.dbUpdate({
+					contract: contractJson,
+					mode,
+					migrationsDir,
+					...consent === void 0 ? {} : { consent },
+					onProgress: controlProgressReporter(ctx.report)
+				});
+				const reported = /* @__PURE__ */ new Set();
+				const reportPlannerWarnings = (warnings) => {
+					for (const warning of warnings) if (!reported.has(warning.summary)) {
+						reported.add(warning.summary);
+						ctx.report({
+							kind: "message",
+							severity: "warn",
+							text: warning.summary
+						});
+					}
+				};
+				let result = await update();
+				if (mode === "apply" && !result.ok && result.failure.code === "DESTRUCTIVE_CHANGES") {
+					reportPlannerWarnings(result.failure.warnings ?? []);
+					const refusal = result.failure.destructiveChanges;
+					if (refusal === void 0 || refusal.destructiveOperations.length === 0) return notOk(normalizeError(errorConsentOperationsMissing()));
+					const token = refusal.databaseName ?? "";
+					if (token.trim().length === 0) return notOk(normalizeError(errorConsentTokenUnresolved(ctx.config.target.targetId)));
+					if (!await ctx.prompt.consent(destructiveConsentQuestion(refusal.destructiveOperations, token), { token })) return notOk(normalizeError(mapDbUpdateFailure(result.failure)));
+					result = await update({ planHash: refusal.planHash });
+				}
+				if (!result.ok) {
+					reportPlannerWarnings(result.failure.warnings ?? []);
+					return notOk(normalizeError(mapDbUpdateFailure(result.failure)));
+				}
+				const advancementHash = result.value.mode === "apply" ? result.value.marker?.storageHash ?? result.value.destination.storageHash : result.value.destination.storageHash;
+				const advancement = await resolveRefAdvancementFields({
+					...ifDefined("advanceRef", args.flags.advanceRef),
+					...ifDefined("db", args.flags.db),
+					refsDir,
+					migrationsDir,
+					contractJson,
+					contractJsonPath: snapshotContractPath,
+					mode: result.value.mode,
+					hash: advancementHash
+				});
+				if (!advancement.ok) return notOk(normalizeError(advancement.failure));
+				document = updateDocument({
+					value: result.value,
+					targetId: ctx.config.target.targetId,
+					advancedRef: advancement.value.advancedRef,
+					plannedAdvanceRef: advancement.value.plannedAdvanceRef,
+					startedAt
+				});
+			} catch (error) {
+				if (error instanceof CliStructuredError$1) throw error;
+				if (CliStructuredError$1$1.is(error)) return notOk(normalizeError(error));
+				if (isStructuredError(error) && error.code === "CONTRACT.VALIDATION_FAILED") return notOk(normalizeError(errorContractValidationFailed(`Contract validation failed: ${error.message}`, { where: { path: contractPath } })));
+				const safeMessage = sanitizeErrorMessage(error instanceof Error ? error.message : String(error), typeof dbConnection === "string" ? dbConnection : void 0);
+				return notOk(normalizeError(errorUnexpected(safeMessage, { why: `Unexpected error during db update: ${safeMessage}` })));
+			} finally {
+				await closeQuietly(client);
+			}
+			ctx.report({
+				kind: "message",
+				severity: "verbose",
+				text: `Total time: ${document.timings.total}ms`
+			});
+			return ok(ctx.present({ data: document }, updatePresentations({
+				document,
+				contractPath: prepared.value.contractDisplayPath,
+				database: prepared.value.database,
+				to: args.flags.to,
+				dryRun: args.flags.dryRun
+			})));
+		}
+	});
+}
+const dbUpdateCommand = createDbUpdateCommand(createControlClient);
 const NOTHING_TO_FORMAT = "Nothing to format (contract source is not PSL).";
 function formatPresentations(document, cwd) {
 	const path = document.path;
@@ -1195,15 +1496,122 @@ function createFormatCommand$1(execute = executeFormat) {
 	});
 }
 const formatCommand = createFormatCommand$1();
-const STATUS_ACTION = runCommandAction("Check every space against the database", "prisma-next migration status");
+/** The invocation that finishes what a failed `init` phase started. */
+const EMIT_COMMAND = "prisma-next contract emit";
 /**
-* The route the migration will take. The graph is a drawing — the engine cannot
-* derive a lane gutter — and the ordered list under it is drawn with the same
-* widths so every arrow lands in one column.
+* The command's own record of a phase that failed after the scaffold was
+* written. The scaffold is on disk and the run has a result to report, so each
+* of these rides a completed envelope as a finding rather than replacing it.
 */
-function showPresentations$1(inputs) {
-	const { document, graph, runList } = inputs;
-	const count = document.migrations.length;
+function initFinding(code, summary, parts) {
+	return {
+		code,
+		severity: "error",
+		summary,
+		why: parts.why,
+		nextActions: parts.nextActions,
+		meta: parts.meta,
+		docsUrl: docsUrlFor(code)
+	};
+}
+/**
+* The dependency install failed. The engine composed and announced the command
+* line, so its own next action — which carries the redacted spelling — is the
+* one that tells the user what to run; `init` adds the emit that was waiting
+* on it.
+*/
+function installFailedFinding(failure, filesWritten) {
+	return initFinding("CLI.INIT_INSTALL_FAILED", "Failed to install dependencies", {
+		why: failure.why ?? failure.message,
+		nextActions: [...failure.nextActions, runCommandAction("Emit the contract once the dependencies are installed", EMIT_COMMAND)],
+		meta: {
+			filesWritten,
+			install: failure.meta ?? {}
+		}
+	});
+}
+/** The first emit failed against the freshly written scaffold. */
+function emitFailedFinding(cause, filesWritten) {
+	return initFinding("CLI.INIT_EMIT_FAILED", "Failed to emit contract", {
+		why: `\`${EMIT_COMMAND}\` failed: ${cause}`,
+		nextActions: [chooseAction("Fix the problem the contract source reports, then emit again"), runCommandAction("Emit the contract", EMIT_COMMAND)],
+		meta: {
+			filesWritten,
+			cause
+		}
+	});
+}
+/**
+* An agent-skill install failed; the project itself is complete without it.
+* The remedy is the skill-install commands themselves, which run against any
+* directory — advising a re-run of `init` would put the user's schema at risk
+* to fix something `init` no longer needs to be involved in.
+*/
+function skillInstallFailedFinding(failure, filesWritten, skillCommands) {
+	return initFinding("CLI.INIT_SKILL_INSTALL_FAILED", "Failed to install Prisma Next skills", {
+		why: failure.why ?? failure.message,
+		nextActions: [...failure.nextActions, ...skillCommands.map((command) => runCommandAction("Install the Prisma Next skills", command))],
+		meta: {
+			filesWritten,
+			skillInstall: failure.meta ?? {}
+		}
+	});
+}
+function fileNodes(paths) {
+	return paths.map((path) => ({
+		label: path,
+		tone: "identifier"
+	}));
+}
+function scaffoldTree(document) {
+	const roots = [{
+		label: "written",
+		tone: "heading",
+		children: fileNodes(document.filesWritten)
+	}];
+	if (document.filesDeleted.length > 0) roots.push({
+		label: "removed (stale artifacts and retired skill directories)",
+		tone: "heading",
+		children: fileNodes(document.filesDeleted)
+	});
+	const installed = document.packagesInstalled;
+	if (installed.status === "installed") roots.push({
+		label: "installed",
+		tone: "heading",
+		children: [...fileNodes(installed.deps), ...installed.devDeps.map((dep) => ({
+			label: `${dep} (dev)`,
+			tone: "identifier"
+		}))]
+	});
+	return {
+		kind: "tree",
+		roots
+	};
+}
+/**
+* The scaffold's follow-up steps, typed. `nextSteps` in the result document
+* keeps its numbered prose for consumers that already read it; these are the
+* same advice in the shape an agent can act on.
+*/
+function buildInitNextActions(inputs) {
+	const actions = [chooseAction("Set DATABASE_URL in your environment (export it or add it to .env)")];
+	if (!inputs.contractEmitted) actions.push(runCommandAction("Emit the contract", EMIT_COMMAND));
+	actions.push({
+		kind: "edit-file",
+		label: `Edit your schema at ${inputs.schemaPath}, then emit again`
+	});
+	actions.push(chooseAction("Open prisma-next.md for a quick reference on writing your first typed query"));
+	if (inputs.skillRegistered) actions.push(chooseAction("Prisma Next skills are registered with your agent runtime — ask it to add a model, run a query, or plan a migration"));
+	return actions;
+}
+const DONE_TEXT = "Done. Open prisma-next.md to get started.";
+const INCOMPLETE_TEXT = "Scaffold written. Finish the steps above to complete setup.";
+/**
+* `init` writes files rather than data another program reads, so it supplies
+* no `stdout` payload: human mode writes nothing to stdout.
+*/
+function initPresentations(inputs) {
+	const { document } = inputs;
 	return {
 		human: () => [
 			{
@@ -1211,44 +1619,849 @@ function showPresentations$1(inputs) {
 				rail: true,
 				rows: [
 					{
-						label: "migrations",
-						value: inputs.migrationsDir
+						label: "target",
+						value: document.target
 					},
-					...inputs.database === void 0 ? [] : [{
-						label: "database",
-						value: inputs.database
-					}],
-					...inputs.from === void 0 ? [] : [{
-						label: "from",
-						value: inputs.from
-					}],
-					...inputs.to === void 0 ? [] : [{
-						label: "to",
-						value: inputs.to
-					}]
+					{
+						label: "authoring",
+						value: document.authoring
+					},
+					{
+						label: "schema",
+						value: document.schemaPath
+					}
 				]
 			},
-			...graph.length === 0 ? [] : [{
-				kind: "drawing",
-				lines: toneDrawing(graph)
-			}],
-			...count === 0 ? [{
+			scaffoldTree(document),
+			inputs.complete ? {
 				kind: "summary",
-				status: "info",
-				text: document.summary
-			}] : [{
+				status: "ok",
+				text: DONE_TEXT
+			} : {
 				kind: "summary",
-				status: "info",
-				text: `The following ${count} migration${count === 1 ? "" : "s"} will run:`
-			}, {
-				kind: "drawing",
-				lines: toneDrawing(runList.join("\n"))
-			}]
+				status: "warn",
+				text: INCOMPLETE_TEXT
+			}
 		],
-		json: () => document
+		json: () => document,
+		next: () => inputs.nextActions
 	};
 }
-function applyPresentations(inputs) {
+/**
+* Emits the contract for the project `init` has just scaffolded.
+*
+* The config file is the one this run wrote, so it is read here rather than
+* through `needs.config`: `init` runs where no config exists yet, and the
+* engine loads a section before the handler starts. The emitter and the config
+* loader are imported at execution time so a run that skips the install — and
+* therefore skips the emit — never pays for either.
+*/
+async function emitScaffoldedContract(ctx) {
+	const { executeContractEmit } = await import("./contract-emit-Bzt11N4v-BQ2Pr8KG.mjs");
+	const { loadConfigForSections } = await import("./exports-BZLNbtkY.mjs").then((n) => n.t);
+	const configPath = join(ctx.cwd, "prisma-next.config.ts");
+	const loaded = await loadConfigForSections(configPath, [
+		"contract",
+		"family",
+		"target",
+		"adapter",
+		"extensions"
+	]);
+	if (!loaded.ok) throw loaded.failure;
+	await executeContractEmit({
+		config: loaded.value,
+		cwd: ctx.cwd,
+		configPath
+	});
+}
+const CONFIG_FILE = "prisma-next.config.ts";
+const QUICK_REFERENCE_FILE = "prisma-next.md";
+const ENV_EXAMPLE_FILE = ".env.example";
+/**
+* The generated files a run replaces outright, in the order it writes them.
+* Everything else the scaffold touches it merges (`tsconfig.json`,
+* `package.json`, the git files) or keeps (`.env`, `README.md`), so replacing
+* one of these is the destructive act consent is asked for.
+*
+* `.env.example` is written the same way but deliberately left out: it is a
+* conventional filename in projects that have never seen Prisma Next, and a
+* consent token demanded for it would fire on first runs. The scaffold warns
+* when it replaces one instead.
+*/
+function generatedFilesInitReplaces(schemaPath) {
+	return [
+		schemaPath,
+		CONFIG_FILE,
+		join(dirname(schemaPath), "db.ts"),
+		QUICK_REFERENCE_FILE
+	];
+}
+const MANAGERS = /* @__PURE__ */ new Set([
+	"pnpm",
+	"npm",
+	"yarn",
+	"bun",
+	"deno"
+]);
+function isPackageManager(name) {
+	return MANAGERS.has(name);
+}
+/**
+* The manager the scaffolded quick reference and README name in their example
+* commands. It resolves the way the engine's package operations resolve theirs
+* — the project at `cwd` first, then the manager that invoked this process —
+* so the documentation `init` writes names the manager `init` drove. The
+* capability itself reports no manager back on success, which is why this is
+* worked out a second time here.
+*/
+async function resolveScaffoldPackageManager(ctx) {
+	const detected = await detect({ cwd: ctx.cwd });
+	if (detected !== null && isPackageManager(detected.name)) return detected.name;
+	const invoking = ctx.env["npm_config_user_agent"]?.split("/")[0];
+	return invoking !== void 0 && isPackageManager(invoking) ? invoking : "npm";
+}
+/**
+* True when the parsed manifest declares `name` directly in `dependencies` or
+* `devDependencies`. Transitive presence is deliberately ignored: detecting it
+* needs the lockfile, and the realistic risk is a direct pin being clobbered.
+*/
+function hasDirectDep(parsed, name) {
+	for (const field of ["dependencies", "devDependencies"]) {
+		const value = parsed[field];
+		if (value !== null && typeof value === "object" && name in value) return true;
+	}
+	return false;
+}
+/**
+* npm package names are lowercase and URL-safe; `basename(cwd)` happily
+* returns "My Project" or ".hidden", both of which npm refuses to read.
+*/
+function sanitisePackageName(raw) {
+	const trimmed = raw.toLowerCase().replace(/[^a-z0-9._~-]/g, "-").replace(/^[._-]+/, "").replace(/-+/g, "-");
+	return trimmed.length > 0 ? trimmed : "my-app";
+}
+/**
+* The manifest `init` writes for a directory that has none. Private, so a
+* stray publish cannot leak the placeholder, and ESM so the scaffolded import
+* attributes load under Node's loader.
+*/
+function defaultPackageJsonContent(rawName) {
+	return `${JSON.stringify({
+		name: sanitisePackageName(rawName),
+		version: "0.0.0",
+		private: true,
+		type: "module"
+	}, null, 2)}\n`;
+}
+function hasProjectManifest(cwd) {
+	return existsSync(join(cwd, "package.json")) || existsSync(join(cwd, "deno.json")) || existsSync(join(cwd, "deno.jsonc"));
+}
+/**
+* Computes every write before touching disk: reads and parses each file the
+* scaffold merges with, so a malformed manifest or tsconfig fails with the
+* user's project byte-identical to how it started.
+*/
+function planScaffold(ctx) {
+	const { cwd, inputs, packageManager, resolveImportSpecifier } = ctx;
+	const warnings = [];
+	const schemaDir = dirname(inputs.schemaPath);
+	const configContractPath = isAbsolute(inputs.schemaPath) ? inputs.schemaPath : `./${inputs.schemaPath}`;
+	const runPrefix = formatRunCommand(packageManager, "prisma-next", "").trimEnd();
+	const files = [
+		{
+			path: inputs.schemaPath,
+			content: starterSchema(inputs.target, inputs.authoring, resolveImportSpecifier)
+		},
+		{
+			path: CONFIG_FILE,
+			content: configFile(inputs.target, configContractPath, resolveImportSpecifier)
+		},
+		{
+			path: join(schemaDir, "db.ts"),
+			content: dbFile(inputs.target, resolveImportSpecifier)
+		},
+		{
+			path: QUICK_REFERENCE_FILE,
+			content: quickReferenceMd(inputs.target, inputs.authoring, inputs.schemaPath, runPrefix, resolveImportSpecifier)
+		},
+		{
+			path: ENV_EXAMPLE_FILE,
+			content: envExampleContent(inputs.target)
+		}
+	];
+	if (existsSync(join(cwd, ENV_EXAMPLE_FILE))) warnings.push(`${ENV_EXAMPLE_FILE} already existed and was replaced with the Prisma Next template.`);
+	const filesToDelete = inputs.reinit ? [...findStaleArtifacts(cwd, schemaDir)] : [];
+	const dirsToDelete = legacySkillDirs().filter((rel) => existsSync(join(cwd, rel)));
+	if (inputs.writeEnv) if (existsSync(join(cwd, ".env"))) warnings.push(".env already exists; leaving it untouched. Compare with .env.example for any new keys.");
+	else files.push({
+		path: ".env",
+		content: envFileContent(inputs.target)
+	});
+	const tsconfigPath = join(cwd, "tsconfig.json");
+	if (existsSync(tsconfigPath)) {
+		const existing = readFileSync(tsconfigPath, "utf-8");
+		let merged;
+		try {
+			merged = mergeTsConfig(existing);
+		} catch (error) {
+			if (error instanceof TsConfigParseError) throw errorInitInvalidTsconfig({
+				path: "tsconfig.json",
+				cause: error.message
+			});
+			throw error;
+		}
+		files.push({
+			path: "tsconfig.json",
+			content: merged,
+			note: "Updated tsconfig.json with required compiler options."
+		});
+	} else files.push({
+		path: "tsconfig.json",
+		content: defaultTsConfig()
+	});
+	const gitignorePath = join(cwd, ".gitignore");
+	const nextGitignore = mergeGitignore(existsSync(gitignorePath) ? readFileSync(gitignorePath, "utf-8") : void 0);
+	if (nextGitignore !== null) files.push({
+		path: ".gitignore",
+		content: nextGitignore
+	});
+	const gitattributesPath = join(cwd, ".gitattributes");
+	const nextGitattributes = mergeGitattributes(existsSync(gitattributesPath) ? readFileSync(gitattributesPath, "utf-8") : void 0, requiredGitattributesLines(schemaDir, inputs.target));
+	if (nextGitattributes !== null) files.push({
+		path: ".gitattributes",
+		content: nextGitattributes
+	});
+	const manifestPath = join(cwd, "package.json");
+	const manifestExisted = existsSync(manifestPath);
+	const synthesiseManifest = !manifestExisted && !hasProjectManifest(cwd);
+	let parsedManifest = null;
+	if (manifestExisted || synthesiseManifest) {
+		const raw = manifestExisted ? readFileSync(manifestPath, "utf-8") : defaultPackageJsonContent(basename(cwd));
+		try {
+			parsedManifest = JSON.parse(raw);
+		} catch (error) {
+			if (error instanceof SyntaxError) throw errorInitInvalidManifest({
+				path: "package.json",
+				cause: error.message
+			});
+			throw error;
+		}
+		let working = raw;
+		let changed = synthesiseManifest;
+		if (inputs.removePreviousFacade !== null) {
+			const next = removeDependency(working, inputs.removePreviousFacade);
+			if (next !== null) {
+				working = next;
+				changed = true;
+			}
+		}
+		const { content: withScripts, warnings: scriptWarnings } = mergePackageScripts(working, REQUIRED_SCRIPTS);
+		if (withScripts !== null) {
+			working = withScripts;
+			changed = true;
+		}
+		const { content: withType, warning: typeWarning } = ensureEsmModuleType(working);
+		if (withType !== null) {
+			working = withType;
+			changed = true;
+		}
+		if (changed) files.push({
+			path: "package.json",
+			content: working
+		});
+		warnings.push(...scriptWarnings);
+		if (typeWarning !== null) warnings.push(typeWarning);
+		if (synthesiseManifest) warnings.push("No package.json found in the target directory; created a minimal one. Edit `name` / `version` to taste.");
+	}
+	if (existsSync(join(cwd, "src/index.ts"))) if (existsSync(join(cwd, "README.md"))) warnings.push("README.md already exists; leaving it untouched.");
+	else {
+		const declaredName = parsedManifest !== null && typeof parsedManifest["name"] === "string" ? parsedManifest["name"] : basename(cwd);
+		files.push({
+			path: "README.md",
+			content: minimalProjectReadmeMd(inputs.target, inputs.schemaPath, sanitisePackageName(declaredName), packageManager)
+		});
+	}
+	return {
+		files,
+		filesToDelete,
+		dirsToDelete,
+		warnings,
+		hasTypesNode: parsedManifest !== null && hasDirectDep(parsedManifest, "@types/node")
+	};
+}
+/**
+* Plans every write, then performs them. Everything that can fail on the
+* user's existing files fails during planning, so a failure leaves the project
+* as it was; after the first write, the scaffold is on disk to keep, and a
+* write that fails partway names the files that already landed.
+*/
+function scaffoldProject(ctx) {
+	const resolveImportSpecifier = scaffoldSpecifierResolverFor(ctx.inputs.target);
+	const plan = planScaffold({
+		...ctx,
+		resolveImportSpecifier
+	});
+	const filesWritten = [];
+	const filesDeleted = [];
+	const notes = [];
+	for (const file of plan.files) {
+		const target = join(ctx.cwd, file.path);
+		try {
+			mkdirSync(dirname(target), { recursive: true });
+			writeFileSync(target, file.content, "utf-8");
+		} catch (error) {
+			throw errorInitWriteFailed({
+				path: file.path,
+				cause: error instanceof Error ? error.message : String(error),
+				filesWritten
+			});
+		}
+		filesWritten.push(file.path);
+		if (file.note !== void 0) notes.push(file.note);
+	}
+	for (const rel of plan.filesToDelete) {
+		const target = join(ctx.cwd, rel);
+		if (!existsSync(target)) continue;
+		try {
+			unlinkSync(target);
+			filesDeleted.push(rel);
+		} catch (error) {
+			if (!(error instanceof Error && Reflect.get(error, "code") === "ENOENT")) throw error;
+		}
+	}
+	for (const rel of plan.dirsToDelete) {
+		rmSync(join(ctx.cwd, rel), {
+			recursive: true,
+			force: true
+		});
+		filesDeleted.push(rel);
+	}
+	return {
+		filesWritten,
+		filesDeleted,
+		warnings: plan.warnings,
+		notes,
+		hasTypesNode: plan.hasTypesNode,
+		resolveImportSpecifier
+	};
+}
+const REQUIRED_FLAG_PROMPTS = /* @__PURE__ */ new Set(["target", "authoring"]);
+function formatFileList(files) {
+	const last = files.at(-1) ?? "";
+	return files.length <= 1 ? last : `${files.slice(0, -1).join(", ")} and ${last}`;
+}
+/**
+* Names the files at stake rather than the category they belong to: the user
+* knows `contract.prisma`, not "every generated file".
+*/
+function consentQuestion(replaced) {
+	const written = replaced.length === 1 ? "it" : "them";
+	return `Re-initializing replaces ${formatFileList(replaced)} with a fresh scaffold, losing anything you wrote in ${written}.`;
+}
+/**
+* The engine raises this when a prompt has no default and the session cannot
+* show it. For the two prompts that stand in for a required flag, that is the
+* same condition `init` has always reported as a missing flag.
+*/
+function isPromptRequired(error) {
+	return error instanceof Error && Reflect.get(error, "code") === "CLI.PROMPT_REQUIRED";
+}
+/**
+* `--confirm` matches a token, so the token has to be something the user can
+* see and type. The working directory's name is it; a directory with no name
+* of its own (the filesystem root) falls back to its path.
+*
+* Trimmed, because the engine compares the typed answer trimmed: an untrimmed
+* token from a directory named `my app ` is one no keystroke sequence matches.
+*/
+function consentToken(cwd) {
+	const name = basename(cwd).trim();
+	return name.length > 0 ? name : cwd.trim();
+}
+async function askTarget(prompt) {
+	return prompt.select("What database are you using?", [{
+		value: "postgres",
+		label: "PostgreSQL"
+	}, {
+		value: "mongo",
+		label: "MongoDB"
+	}]);
+}
+async function askAuthoring(prompt) {
+	return prompt.select("How do you want to write your schema?", [{
+		value: "psl",
+		label: "Prisma Schema Language (.prisma)"
+	}, {
+		value: "typescript",
+		label: "TypeScript (.ts)"
+	}]);
+}
+/**
+* The schema path the user typed goes through the same validator the flag
+* does, so an answer the engine accepted still has to agree with the authoring
+* style.
+*/
+async function askSchemaPath(prompt, authoring) {
+	return validateSchemaPath(await prompt.text("Where should the schema file go?", { default: defaultSchemaPath(authoring) }), authoring);
+}
+/**
+* The facade a previous `init` installed for the other target, when this run
+* switches targets and one is still declared. Reads every name a previous run
+* could have written, because older versions scaffolded the workspace name.
+*/
+function previousFacade(cwd, target) {
+	const manifestPath = join(cwd, "package.json");
+	if (!existsSync(manifestPath)) return;
+	const otherTarget = target === "postgres" ? "mongo" : "postgres";
+	const candidates = [targetPackageName(otherTarget, scaffoldSpecifierResolverFor(otherTarget)), targetPackageName(otherTarget)];
+	let parsed;
+	try {
+		parsed = JSON.parse(readFileSync(manifestPath, "utf-8"));
+	} catch {
+		return;
+	}
+	const deps = parsed["dependencies"];
+	if (deps === null || typeof deps !== "object" || Array.isArray(deps)) return;
+	const declared = deps;
+	return candidates.find((name) => Object.hasOwn(declared, name));
+}
+async function resolveRemovePreviousFacade(ctx) {
+	if (!ctx.reinit || ctx.keepPreviousFacade) return null;
+	const facade = previousFacade(ctx.cwd, ctx.target);
+	if (facade === void 0) return null;
+	const otherTarget = ctx.target === "postgres" ? "mongo" : "postgres";
+	return await ctx.prompt.confirm(`Switching from ${targetLabel(otherTarget)} to ${targetLabel(ctx.target)} — remove ${facade} from package.json dependencies?`, { default: true }) ? facade : null;
+}
+/**
+* Resolves every input from the flags and, where a flag is absent, from the
+* engine's prompt surface.
+*
+* Order matters twice. Every flag value is validated before anything is asked,
+* so a typo costs a typo rather than a typed consent token. And consent comes
+* as soon as the schema path is known, because that is the point at which the
+* question can name the files it is about — and before any question whose
+* answer only matters if the run proceeds.
+*/
+async function resolveInitInputs(ctx) {
+	const { cwd, flags, prompt } = ctx;
+	if (flags.strictProbe && !flags.probeDb) throw errorInitStrictProbeWithoutProbe();
+	const flagTarget = resolveTarget(flags.target);
+	const flagAuthoring = resolveAuthoring(flags.authoring);
+	let target;
+	let authoring;
+	try {
+		target = flagTarget ?? await askTarget(prompt);
+		authoring = flagAuthoring ?? await askAuthoring(prompt);
+	} catch (error) {
+		if (!isPromptRequired(error)) throw error;
+		throw errorInitMissingFlags({
+			missing: [...flagTarget === void 0 ? ["target"] : [], ...flagAuthoring === void 0 ? ["authoring"] : []].filter((flag) => REQUIRED_FLAG_PROMPTS.has(flag)),
+			why: "This session cannot prompt, so the answers have to arrive as flags."
+		});
+	}
+	const schemaPath = flags.schemaPath !== void 0 ? validateSchemaPath(flags.schemaPath, authoring) : await askSchemaPath(prompt, authoring);
+	const replaced = generatedFilesInitReplaces(schemaPath).filter((relative) => existsSync(join(cwd, relative)));
+	const reinit = replaced.length > 0;
+	if (reinit) {
+		if (!await prompt.consent(consentQuestion(replaced), { token: consentToken(cwd) })) throw errorInitUserAborted();
+	}
+	const writeEnv = flags.writeEnv || await prompt.confirm("Also write a .env file from .env.example? (gitignored)", { default: false });
+	const removePreviousFacade = await resolveRemovePreviousFacade({
+		cwd,
+		target,
+		reinit,
+		keepPreviousFacade: flags.keepPreviousFacade,
+		prompt
+	});
+	return {
+		target,
+		authoring,
+		schemaPath,
+		install: !flags.skipInstall,
+		writeEnv,
+		probeDb: flags.probeDb,
+		strictProbe: flags.strictProbe,
+		reinit,
+		removePreviousFacade,
+		installProjectSkill: !flags.skipSkills
+	};
+}
+function metaString(failure, key) {
+	const value = failure.meta?.[key];
+	return typeof value === "string" ? value : "";
+}
+/**
+* pnpm reported a specifier the published artifact leaked, which npm installs
+* happily. The engine redacts credentials out of the stderr it returns but
+* leaves error codes alone, which is what this reads.
+*/
+function pnpmLeakedASpecifier(failure) {
+	return metaString(failure, "manager") === "pnpm" && isRecognisedPnpmResolutionError(metaString(failure, "stderrTail"));
+}
+/**
+* The engine redacts the stderr it hands back, and this redacts it again
+* before quoting it: what the engine strips is its own business, and registry
+* auth material is not all URL-shaped.
+*/
+function fallbackWarning(failure) {
+	const firstLine = redactSecrets(metaString(failure, "stderrTail")).trim().split("\n")[0] ?? "";
+	return [
+		"pnpm could not install: a published Prisma Next dependency leaked a `workspace:*` or `catalog:` specifier.",
+		"Falling back to npm so init can complete.",
+		firstLine === "" ? "" : `  pnpm error: ${firstLine}`,
+		"Both installs ran under npm, which writes a package-lock.json beside the pnpm lockfile — delete whichever of the two you do not want to keep.",
+		"Once the offending package republishes a clean version, re-run `pnpm install` to switch back."
+	].filter((line) => line !== "").join("\n");
+}
+/** The pnpm failure the npm retry was meant to recover from, kept alongside the npm one. */
+function retriedWarning(failure) {
+	const firstLine = redactSecrets(metaString(failure, "stderrTail")).trim().split("\n")[0] ?? "";
+	return ["pnpm failed first with a leaked `workspace:*` or `catalog:` specifier, so init retried with npm.", firstLine === "" ? "" : `  pnpm error: ${firstLine}`].filter((line) => line !== "").join("\n");
+}
+/**
+* Adds the runtime and development dependencies through the engine's package
+* manager. The retry is `init`'s alone: the engine spells and runs the
+* command, and this decides — from the stderr it returned — that another
+* manager is worth a try.
+*/
+async function installProjectDependencies(ctx) {
+	const pair = async (manager) => {
+		const runtimeDeps = await ctx.packages.install({
+			packages: ctx.deps,
+			cwd: ctx.cwd,
+			...ifDefined("manager", manager)
+		});
+		if (!runtimeDeps.ok) return runtimeDeps.failure;
+		const developmentDeps = await ctx.packages.install({
+			packages: ctx.devDeps,
+			dev: true,
+			cwd: ctx.cwd,
+			...ifDefined("manager", manager)
+		});
+		return developmentDeps.ok ? void 0 : developmentDeps.failure;
+	};
+	const failure = await pair();
+	if (failure === void 0) return {
+		failure: void 0,
+		manager: void 0,
+		warnings: ctx.catalogWarnings
+	};
+	if (!pnpmLeakedASpecifier(failure)) return {
+		failure,
+		manager: void 0,
+		warnings: []
+	};
+	const retryFailure = await pair("npm");
+	if (retryFailure !== void 0) return {
+		failure: retryFailure,
+		manager: void 0,
+		warnings: [retriedWarning(failure)]
+	};
+	return {
+		failure: void 0,
+		manager: "npm",
+		warnings: [fallbackWarning(failure)]
+	};
+}
+function skillArgs(url, skill) {
+	return [
+		"add",
+		url,
+		"--agent",
+		...DEFAULT_SKILL_AGENTS,
+		"--skill",
+		skill,
+		"-y"
+	];
+}
+/**
+* Registers every Prisma Next skill with the agent runtimes, in order. The
+* first failure stops the loop: the user opted into Prisma Next by running
+* `init`, and a half-installed skill set leaves the project ambiguous.
+*/
+async function installAgentSkills(ctx) {
+	for (const source of DEFAULT_SKILL_SOURCES) {
+		const result = await ctx.packages.run({
+			package: "skills@latest",
+			args: skillArgs(formatSkillSourceUrl(source, ctx.env), source.skill),
+			cwd: ctx.cwd,
+			...ifDefined("manager", ctx.manager)
+		});
+		if (!result.ok) return result.failure;
+	}
+}
+/** The scaffold is on disk from here on, so each of these is a finding. */
+const INIT_EXIT_CODES = {
+	4: "scaffold written; dependency install failed",
+	5: "scaffold written and installed; contract emit failed",
+	6: "scaffold complete; agent-skill install failed"
+};
+function probeWarning(outcome, strictProbe) {
+	switch (outcome.kind) {
+		case "ok": return {
+			warning: void 0,
+			fatal: void 0
+		};
+		case "below-minimum": return {
+			warning: outcome.message,
+			fatal: void 0
+		};
+		case "no-database-url":
+		case "connection-failed":
+		case "driver-missing": return strictProbe ? {
+			warning: void 0,
+			fatal: outcome.message
+		} : {
+			warning: outcome.message,
+			fatal: void 0
+		};
+	}
+}
+function causeMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+const createInitCommand = (injected) => defineOrmCommand({
+	help: {
+		summary: "Initialize a new Prisma Next project",
+		description: "Scaffolds config, schema, and runtime files, installs dependencies,\nand emits the contract. Gets you from zero to typed queries in one step.\n\nRun it interactively for a guided setup, or supply --target and --authoring\nfor a fully scriptable run (CI, AI coding agents, automation).",
+		examples: [
+			"init",
+			"init --target postgres --authoring psl",
+			"init --target mongodb --authoring typescript --json",
+			"init --skip-install",
+			"init --skip-skills",
+			"init --target postgres --keep-previous-facade"
+		]
+	},
+	args: { flags: {
+		target: flag.string({
+			brief: "Database target: postgres or mongodb",
+			placeholder: "db"
+		}),
+		authoring: flag.string({
+			brief: "Schema authoring style: psl or typescript",
+			placeholder: "style"
+		}),
+		schemaPath: flag.string({
+			brief: "Where to write the starter schema",
+			placeholder: "path"
+		}),
+		writeEnv: flag.boolean({ brief: "Write a .env file from .env.example (gitignored)" }),
+		probeDb: flag.boolean({ brief: "Connect to DATABASE_URL once and check the server version" }),
+		strictProbe: flag.boolean({ brief: "Treat a failed --probe-db as fatal" }),
+		skipInstall: flag.boolean({ brief: "Skip dependency installation and contract emission" }),
+		skipSkills: flag.boolean({ brief: "Skip the Prisma Next agent-skill install" }),
+		keepPreviousFacade: flag.boolean({ brief: "Keep the previous target package in package.json when switching targets" })
+	} },
+	exitCodes: INIT_EXIT_CODES,
+	installsPackages: true,
+	handler: async (args, ctx) => {
+		const warnings = [];
+		const warn = (text) => {
+			warnings.push(text);
+			ctx.report({
+				kind: "message",
+				severity: "warn",
+				text
+			});
+		};
+		const inputs = await resolveInitInputs({
+			cwd: ctx.cwd,
+			flags: args.flags,
+			prompt: ctx.prompt
+		});
+		const packageManager = await resolveScaffoldPackageManager({
+			cwd: ctx.cwd,
+			env: ctx.env
+		});
+		const scaffold = scaffoldProject({
+			cwd: ctx.cwd,
+			inputs,
+			packageManager
+		});
+		for (const warning of scaffold.warnings) warn(warning);
+		for (const note of scaffold.notes) ctx.report({
+			kind: "message",
+			severity: "info",
+			text: note
+		});
+		const deps = [targetPackageName(inputs.target, scaffold.resolveImportSpecifier), "dotenv"];
+		const devDeps = scaffold.hasTypesNode ? ["prisma-next"] : ["prisma-next", "@types/node"];
+		const findings = [];
+		const extraActions = [];
+		let installedManager;
+		let packagesInstalled = "skipped";
+		let contractEmitted = false;
+		let skillRegistered = false;
+		const settle = (exitCode) => {
+			const installed = packagesInstalled === "installed";
+			const document = {
+				ok: true,
+				target: inputs.target === "mongo" ? "mongodb" : "postgres",
+				authoring: inputs.authoring,
+				schemaPath: inputs.schemaPath,
+				filesWritten: scaffold.filesWritten,
+				filesDeleted: scaffold.filesDeleted,
+				packagesInstalled: {
+					status: packagesInstalled,
+					deps: installed ? deps : [],
+					devDeps: installed ? devDeps : []
+				},
+				contractEmitted,
+				nextSteps: buildNextSteps({
+					target: inputs.target === "mongo" ? "mongodb" : "postgres",
+					packagesInstalled,
+					contractEmitted,
+					emitCommand: EMIT_COMMAND,
+					schemaPath: inputs.schemaPath,
+					skillRegistered
+				}),
+				warnings
+			};
+			const validated = InitOutputSchema(document);
+			if (validated instanceof type.errors) return notOk(new CliStructuredError$1("CLI.INIT_INVALID_OUTPUT_DOCUMENT", "Init produced an invalid output document", {
+				why: `The success document failed schema validation: ${String(validated)}`,
+				nextActions: [chooseAction("This is a bug in prisma-next. Please report it with `-v` output.")],
+				docsUrl: docsUrlFor("CLI.INIT_INVALID_OUTPUT_DOCUMENT")
+			}));
+			return ok(ctx.present({
+				data: document,
+				exitCode,
+				diagnostics: findings
+			}, initPresentations({
+				document,
+				complete: exitCode === 0,
+				nextActions: [...extraActions, ...buildInitNextActions({
+					contractEmitted,
+					schemaPath: inputs.schemaPath,
+					skillRegistered
+				})]
+			})));
+		};
+		if (inputs.install) {
+			const outcome = await installProjectDependencies({
+				packages: ctx.packages,
+				cwd: ctx.cwd,
+				deps,
+				devDeps,
+				catalogWarnings: packageManager === "pnpm" ? buildCatalogWarnings(ctx.cwd, [...deps, ...devDeps]) : []
+			});
+			for (const warning of outcome.warnings) warn(warning);
+			if (outcome.failure !== void 0) {
+				packagesInstalled = "failed";
+				findings.push(installFailedFinding(outcome.failure, scaffold.filesWritten));
+				return settle(4);
+			}
+			packagesInstalled = "installed";
+			installedManager = outcome.manager;
+			const emitStep = "Emit the contract";
+			ctx.report({
+				kind: "step-started",
+				step: emitStep
+			});
+			try {
+				await injected.emitScaffoldedContract({ cwd: ctx.cwd });
+				contractEmitted = true;
+				ctx.report({
+					kind: "step-finished",
+					step: emitStep,
+					outcome: "ok"
+				});
+			} catch (error) {
+				ctx.report({
+					kind: "step-finished",
+					step: emitStep,
+					outcome: "failed"
+				});
+				findings.push(emitFailedFinding(causeMessage(error), scaffold.filesWritten));
+				return settle(5);
+			}
+		} else extraActions.push(chooseAction(`Install the project dependencies with your package manager: ${deps.join(", ")} (and ${devDeps.join(", ")} as development dependencies)`));
+		if (inputs.probeDb) {
+			const probe = probeWarning(await probeServerVersion({
+				baseDir: ctx.cwd,
+				target: inputs.target,
+				databaseUrl: ctx.env["DATABASE_URL"],
+				minVersion: MIN_SERVER_VERSION[inputs.target]
+			}, {}), inputs.strictProbe);
+			if (probe.warning !== void 0) warn(probe.warning);
+			if (probe.fatal !== void 0) return notOk(normalizeError(errorInitProbeFailed({
+				cause: probe.fatal,
+				filesWritten: scaffold.filesWritten
+			})));
+		}
+		const skillCommands = resolveProjectSkillInstallCommands(installedManager ?? packageManager, ctx.env);
+		if (inputs.installProjectSkill) {
+			const failure = await installAgentSkills({
+				packages: ctx.packages,
+				cwd: ctx.cwd,
+				env: ctx.env,
+				manager: installedManager
+			});
+			if (failure !== void 0) {
+				findings.push(skillInstallFailedFinding(failure, scaffold.filesWritten, skillCommands));
+				return settle(6);
+			}
+			skillRegistered = true;
+		} else warn(`Skipped the Prisma Next agent-skill install (--skip-skills). To install them later, run: ${skillCommands.map((command) => `\`${command}\``).join(" && ")}`);
+		return settle(0);
+	}
+});
+const initCommand = createInitCommand({ emitScaffoldedContract });
+const STATUS_ACTION = runCommandAction("Check every space against the database", "prisma-next migration status");
+/**
+* The route the migration will take. The graph is a drawing — the engine cannot
+* derive a lane gutter — and the ordered list under it is drawn with the same
+* widths so every arrow lands in one column.
+*/
+function showPresentations$1(inputs) {
+	const { document, graph, runList } = inputs;
+	const count = document.migrations.length;
+	return {
+		human: () => [
+			{
+				kind: "fields",
+				rail: true,
+				rows: [
+					{
+						label: "migrations",
+						value: inputs.migrationsDir
+					},
+					...inputs.database === void 0 ? [] : [{
+						label: "database",
+						value: inputs.database
+					}],
+					...inputs.from === void 0 ? [] : [{
+						label: "from",
+						value: inputs.from
+					}],
+					...inputs.to === void 0 ? [] : [{
+						label: "to",
+						value: inputs.to
+					}]
+				]
+			},
+			...graph.length === 0 ? [] : [{
+				kind: "drawing",
+				lines: toneDrawing(graph)
+			}],
+			...count === 0 ? [{
+				kind: "summary",
+				status: "info",
+				text: document.summary
+			}] : [{
+				kind: "summary",
+				status: "info",
+				text: `The following ${count} migration${count === 1 ? "" : "s"} will run:`
+			}, {
+				kind: "drawing",
+				lines: toneDrawing(runList.join("\n"))
+			}]
+		],
+		json: () => document
+	};
+}
+function applyPresentations(inputs) {
 	const { document } = inputs;
 	const advanced = document.advancedRef;
 	return {
@@ -1737,85 +2950,392 @@ function ledgerGrid(entries, options) {
 		})
 	};
 }
-function logPresentations(inputs) {
-	const grid = inputs.grid;
+function logPresentations(inputs) {
+	const grid = inputs.grid;
+	return {
+		human: () => [...inputs.database === void 0 ? [] : [{
+			kind: "fields",
+			rail: true,
+			rows: [{
+				label: "database",
+				value: inputs.database
+			}]
+		}], ...grid === void 0 ? [{
+			kind: "summary",
+			status: "info",
+			text: MIGRATION_LOG_EMPTY_MESSAGE
+		}] : [{
+			kind: "table",
+			columns: grid.headings,
+			rows: grid.rows
+		}]],
+		json: () => inputs.document
+	};
+}
+const migrationLogCommand = defineOrmCommand({
+	help: {
+		summary: "Show executed migration history",
+		description: "Reads the database ledger and displays every applied migration edge in\nchronological order, including rollbacks and re-applies, merged across\nall contract spaces. Requires a database connection.",
+		examples: [
+			"migration log",
+			"migration log --db $DATABASE_URL",
+			"migration log --utc",
+			"migration log --json"
+		]
+	},
+	args: { flags: {
+		db: dbFlag,
+		utc: flag.boolean({ brief: "Render human timestamps in UTC instead of local time" }),
+		ascii: flag.boolean({ brief: "Use ASCII glyphs (pipe-friendly)" })
+	} },
+	needs: { config: ormConfigSection },
+	handler: async (args, ctx) => {
+		const dbConnection = args.flags.db ?? ctx.config.db?.connection;
+		const missingDb = requireLiveDatabase({
+			dbConnection,
+			hasDriver: ctx.config.driver !== void 0,
+			why: "migration log needs a database connection and driver to read the ledger (set db.connection in prisma-next.config.ts, or pass --db <url>)",
+			commandName: "migration log"
+		});
+		if (missingDb !== null) return notOk(normalizeError(missingDb));
+		if (!targetSupportsMigrations(ctx.config.target)) return notOk(normalizeError(errorTargetMigrationNotSupported({ why: "migration log reads the ledger a migration runner writes, and the configured target provides no runner." })));
+		const client = createControlClient({
+			family: ctx.config.family,
+			target: ctx.config.target,
+			adapter: ctx.config.adapter,
+			...ifDefined("driver", ctx.config.driver),
+			extensions: ctx.config.extensions ?? []
+		});
+		let entries;
+		try {
+			await client.connect(dbConnection);
+			entries = await client.readLedger();
+		} catch (error) {
+			return notOk(normalizeError(mapCaughtMigrationError(error) ?? errorUnexpected(error instanceof Error ? error.message : String(error), { why: `Failed to read migration log: ${error instanceof Error ? error.message : String(error)}` })));
+		} finally {
+			await closeQuietly(client);
+		}
+		const records = serializeLedgerEntriesForJson(entries);
+		const document = {
+			ok: true,
+			records,
+			summary: `${records.length} migration(s) applied`
+		};
+		const glyphMode = args.flags.ascii ? "ascii" : "unicode";
+		return ok(ctx.present({ data: document }, logPresentations({
+			document,
+			grid: entries.length === 0 ? void 0 : ledgerGrid(entries, {
+				utc: args.flags.utc,
+				glyphMode
+			}),
+			database: typeof dbConnection === "string" ? maskConnectionUrl(dbConnection) : void 0
+		})));
+	}
+});
+function newPresentations(inputs) {
+	const { document } = inputs;
+	const migrationTs = join(document.dir, "migration.ts");
+	return {
+		human: () => [
+			{
+				kind: "fields",
+				rail: true,
+				rows: [{
+					label: "contract",
+					value: inputs.contractPath
+				}, {
+					label: "migrations",
+					value: inputs.appMigrationsRelative
+				}]
+			},
+			{
+				kind: "summary",
+				status: "ok",
+				text: document.summary
+			},
+			{
+				kind: "fields",
+				rows: [{
+					label: "from",
+					value: document.from === null ? [{
+						text: "(baseline)",
+						tone: "muted"
+					}] : [{
+						text: document.from,
+						tone: "identifier"
+					}]
+				}, {
+					label: "to",
+					value: [{
+						text: document.to,
+						tone: "identifier"
+					}]
+				}]
+			}
+		],
+		json: () => document,
+		next: () => [{
+			kind: "edit-file",
+			label: `Write the migration body in ${migrationTs}`
+		}, runCommandAction("Run it to self-emit ops.json and attest the package", `node "${migrationTs}"`)]
+	};
+}
+const migrationNewCommand = defineOrmCommand({
+	help: {
+		summary: "Scaffold a new migration for manual authoring",
+		description: "Creates a migration package with a migration.ts file for manual authoring.\nWrite the migration body in migration.ts, then run the file with Node\n(`node migration.ts`) to self-emit ops.json and attest the package.\nOffline — does not consult the database.",
+		examples: [
+			"migration new --name split-name",
+			"migration new --name custom-fk --from abc123",
+			"migration new --json"
+		]
+	},
+	args: { flags: {
+		name: flag.string({
+			brief: "Migration name (used in directory name)",
+			placeholder: "slug"
+		}),
+		from: flag.string({
+			brief: "Starting contract hash (default: latest migration target)",
+			placeholder: "hash"
+		})
+	} },
+	needs: { config: ormConfigSection },
+	handler: async (args, ctx) => {
+		const scaffolded = await executeMigrationNewCommand({
+			config: ctx.config,
+			cwd: ctx.cwd,
+			configPath: projectConfigPathFor(ctx.cwd),
+			...ifDefined("name", args.flags.name),
+			...ifDefined("from", args.flags.from)
+		});
+		if (!scaffolded.ok) return notOk(normalizeError(scaffolded.failure));
+		const contractPath = contractPathFor(ctx.config, ctx.cwd);
+		return ok(ctx.present({ data: scaffolded.value }, newPresentations({
+			document: scaffolded.value,
+			contractPath: contractPath === void 0 ? "(unset)" : displayPath(contractPath, ctx.cwd),
+			appMigrationsRelative: displayPath(appMigrationsDirFor(ctx.config, ctx.cwd), ctx.cwd)
+		})));
+	}
+});
+function hashRow(label, hash) {
+	return {
+		label,
+		value: hash === null ? [{
+			text: "(baseline)",
+			tone: "muted"
+		}] : [{
+			text: hash,
+			tone: "identifier"
+		}]
+	};
+}
+/**
+* Where the run put things: the contract edge it planned, then every directory
+* it wrote — the app-space package, the auto-baseline package that precedes it,
+* and any extension-space package the seed phase materialised.
+*/
+function outcomeFields(result, migrationsRelative) {
+	return {
+		kind: "fields",
+		rows: [
+			hashRow("from", result.from),
+			hashRow("to", result.to),
+			...result.baselineDir === void 0 ? [] : [{
+				label: "baseline",
+				value: result.baselineDir
+			}],
+			...result.dir === void 0 ? [] : [{
+				label: "app space",
+				value: result.dir
+			}],
+			...result.emittedExtensionDirs.map((entry) => ({
+				label: `space ${entry.spaceId}`,
+				value: join(migrationsRelative, entry.spaceId, entry.dirName)
+			}))
+		]
+	};
+}
+function operationNodes$1(result) {
+	return result.operations.map((operation) => operation.operationClass === "destructive" ? {
+		label: operation.label,
+		status: "warn"
+	} : { label: operation.label });
+}
+function operationBlocks$1(result) {
+	if (result.operations.length === 0) return [];
+	const destructive = result.operations.some((operation) => operation.operationClass === "destructive");
+	return [{
+		kind: "tree",
+		roots: [{
+			label: result.dir ?? "operations",
+			children: operationNodes$1(result)
+		}]
+	}, ...destructive ? [{
+		kind: "summary",
+		status: "warn",
+		text: "This migration contains destructive operations that may cause data loss."
+	}] : []];
+}
+/** Statements a database would run, printed verbatim rather than laid out. */
+function previewBlocks$1(result) {
+	const preview = result.preview;
+	if (preview === void 0) return [];
+	const statements = preview.statements.map((statement) => statement.text.trim()).filter((text) => text.length > 0).map((text) => text.endsWith(";") ? text : `${text};`);
+	if (statements.length === 0) return [];
+	return [{
+		kind: "summary",
+		status: "info",
+		tone: "muted",
+		text: previewBlockHeader(preview)
+	}, {
+		kind: "drawing",
+		lines: statements
+	}];
+}
+function planBlocks(result, migrationsRelative) {
+	const outcome = outcomeFields(result, migrationsRelative);
+	if (result.noOp) return [{
+		kind: "summary",
+		status: "ok",
+		text: "No changes detected"
+	}, outcome];
+	if (result.pendingPlaceholders === true) return [{
+		kind: "summary",
+		status: "warn",
+		text: result.summary
+	}, outcome];
+	return [
+		{
+			kind: "summary",
+			status: "ok",
+			text: result.summary
+		},
+		...operationBlocks$1(result),
+		outcome,
+		...previewBlocks$1(result)
+	];
+}
+function planNextActions(result, migrationsRelative) {
+	if (result.pendingPlaceholders === true) {
+		const migrationTs = join(result.dir ?? "<dir>", "migration.ts");
+		return [{
+			kind: "edit-file",
+			label: `Replace each placeholder(...) call in ${migrationTs} with your query`
+		}, runCommandAction("Run it to self-emit ops.json and attest the package", `node "${migrationTs}"`)];
+	}
+	const written = [
+		...result.baselineDir === void 0 ? [] : [result.baselineDir],
+		...result.dir === void 0 ? [] : [result.dir],
+		...result.emittedExtensionDirs.map((entry) => join(migrationsRelative, entry.spaceId, entry.dirName))
+	];
+	if (written.length === 0) return [];
+	return [{
+		kind: "edit-file",
+		label: `Review ${written.join(" and ")}`
+	}, runCommandAction("Apply the migration", "prisma-next migrate")];
+}
+function planPresentations(inputs) {
 	return {
-		human: () => [...inputs.database === void 0 ? [] : [{
+		human: () => [{
 			kind: "fields",
 			rail: true,
-			rows: [{
-				label: "database",
-				value: inputs.database
-			}]
-		}], ...grid === void 0 ? [{
-			kind: "summary",
-			status: "info",
-			text: MIGRATION_LOG_EMPTY_MESSAGE
-		}] : [{
-			kind: "table",
-			columns: grid.headings,
-			rows: grid.rows
-		}]],
-		json: () => inputs.document
+			rows: [
+				{
+					label: "contract",
+					value: inputs.contractPath
+				},
+				{
+					label: "migrations",
+					value: inputs.appMigrationsRelative
+				},
+				...inputs.from === void 0 ? [] : [{
+					label: "from",
+					value: inputs.from
+				}],
+				...inputs.to === void 0 ? [] : [{
+					label: "to",
+					value: inputs.to
+				}],
+				...inputs.name === void 0 ? [] : [{
+					label: "name",
+					value: inputs.name
+				}]
+			]
+		}, ...planBlocks(inputs.document, inputs.migrationsRelative)],
+		json: () => inputs.document,
+		next: () => planNextActions(inputs.document, inputs.migrationsRelative)
 	};
 }
-const migrationLogCommand = defineOrmCommand({
+const migrationPlanCommand = defineOrmCommand({
 	help: {
-		summary: "Show executed migration history",
-		description: "Reads the database ledger and displays every applied migration edge in\nchronological order, including rollbacks and re-applies, merged across\nall contract spaces. Requires a database connection.",
+		summary: "Plan a migration from contract changes",
+		description: "Compares the emitted contract against the latest on-disk migration state\nand produces a new migration package with the required operations.\nOffline — does not consult the database.",
 		examples: [
-			"migration log",
-			"migration log --db $DATABASE_URL",
-			"migration log --utc",
-			"migration log --json"
+			"migration plan",
+			"migration plan --name add-users-table",
+			"migration plan --to <migration-dir>^ --name rollback",
+			"migration plan --json"
 		]
 	},
 	args: { flags: {
-		db: dbFlag,
-		utc: flag.boolean({ brief: "Render human timestamps in UTC instead of local time" }),
-		ascii: flag.boolean({ brief: "Use ASCII glyphs (pipe-friendly)" })
+		name: flag.string({
+			brief: "Name slug for the migration directory",
+			placeholder: "slug"
+		}),
+		from: flag.string({
+			brief: "Starting contract reference (hash, prefix, ref name, migration dir name, <dir>^, or ./path)",
+			placeholder: "contract"
+		}),
+		to: flag.string({
+			brief: "Destination contract reference; defaults to the emitted contract. Same grammar as --from",
+			placeholder: "contract"
+		})
 	} },
 	needs: { config: ormConfigSection },
 	handler: async (args, ctx) => {
-		const dbConnection = args.flags.db ?? ctx.config.db?.connection;
-		const missingDb = requireLiveDatabase({
-			dbConnection,
-			hasDriver: ctx.config.driver !== void 0,
-			why: "migration log needs a database connection and driver to read the ledger (set db.connection in prisma-next.config.ts, or pass --db <url>)",
-			commandName: "migration log"
-		});
-		if (missingDb !== null) return notOk(normalizeError(missingDb));
-		if (!targetSupportsMigrations(ctx.config.target)) return notOk(normalizeError(errorTargetMigrationNotSupported({ why: "migration log reads the ledger a migration runner writes, and the configured target provides no runner." })));
-		const client = createControlClient({
-			family: ctx.config.family,
-			target: ctx.config.target,
-			adapter: ctx.config.adapter,
-			...ifDefined("driver", ctx.config.driver),
-			extensions: ctx.config.extensions ?? []
-		});
-		let entries;
-		try {
-			await client.connect(dbConnection);
-			entries = await client.readLedger();
-		} catch (error) {
-			return notOk(normalizeError(mapCaughtMigrationError(error) ?? errorUnexpected(error instanceof Error ? error.message : String(error), { why: `Failed to read migration log: ${error instanceof Error ? error.message : String(error)}` })));
-		} finally {
-			await closeQuietly(client);
-		}
-		const records = serializeLedgerEntriesForJson(entries);
-		const document = {
-			ok: true,
-			records,
-			summary: `${records.length} migration(s) applied`
+		const seeded = (record) => {
+			if (record.action !== "updated") return;
+			const step = `Seed contract space ${record.spaceId}`;
+			ctx.report({
+				kind: "step-started",
+				step,
+				id: record.spaceId
+			});
+			ctx.report({
+				kind: "step-finished",
+				step,
+				id: record.spaceId,
+				outcome: "ok",
+				data: {
+					newHash: record.newHash,
+					newMigrationDirs: record.newMigrationDirs
+				}
+			});
 		};
-		const glyphMode = args.flags.ascii ? "ascii" : "unicode";
-		return ok(ctx.present({ data: document }, logPresentations({
-			document,
-			grid: entries.length === 0 ? void 0 : ledgerGrid(entries, {
-				utc: args.flags.utc,
-				glyphMode
-			}),
-			database: typeof dbConnection === "string" ? maskConnectionUrl(dbConnection) : void 0
+		const planned = await executeMigrationPlanCommand({
+			config: ctx.config,
+			cwd: ctx.cwd,
+			configPath: projectConfigPathFor(ctx.cwd),
+			...ifDefined("name", args.flags.name),
+			...ifDefined("from", args.flags.from),
+			...ifDefined("to", args.flags.to)
+		}, Date.now(), { onSeeded: seeded });
+		if (!planned.ok) return notOk(normalizeError(planned.failure));
+		ctx.report({
+			kind: "message",
+			severity: "verbose",
+			text: `Total time: ${planned.value.timings.total}ms`
+		});
+		const contractPath = contractPathFor(ctx.config, ctx.cwd);
+		return ok(ctx.present({ data: planned.value }, planPresentations({
+			document: planned.value,
+			contractPath: contractPath === void 0 ? "(unset)" : displayPath(contractPath, ctx.cwd),
+			appMigrationsRelative: displayPath(appMigrationsDirFor(ctx.config, ctx.cwd), ctx.cwd),
+			migrationsRelative: displayPath(migrationsDirFor(ctx.config, ctx.cwd), ctx.cwd),
+			from: args.flags.from,
+			to: args.flags.to,
+			name: args.flags.name
 		})));
 	}
 });
@@ -2053,6 +3573,426 @@ const migrationShowCommand = defineOrmCommand({
 		})));
 	}
 });
+const EMIT_CONTRACT = runCommandAction("Regenerate the contract", "prisma-next contract emit");
+function contractUnreadableFinding(reason) {
+	const message = `Could not read contract: ${reason}`;
+	return {
+		document: {
+			code: "CONTRACT.UNREADABLE",
+			severity: "warn",
+			message,
+			hints: ["Run 'prisma-next contract emit' to generate a valid contract"]
+		},
+		diagnostic: {
+			code: "CONTRACT.UNREADABLE",
+			severity: "warn",
+			summary: message,
+			why: "The status tree falls back to the on-disk migration graph when the emitted contract cannot be read.",
+			nextActions: [EMIT_CONTRACT]
+		}
+	};
+}
+function markerNotInHistoryFinding(space) {
+	const message = `Database was updated outside the migration system (marker for space "${space}" does not match any migration)`;
+	return {
+		document: {
+			code: "MIGRATION.MARKER_NOT_IN_HISTORY",
+			severity: "warn",
+			message,
+			hints: ["Run 'prisma-next db sign' to overwrite the marker if the database already matches the contract", "Run 'prisma-next db update' to push the current contract to the database"]
+		},
+		diagnostic: {
+			code: "MIGRATION.MARKER_NOT_IN_HISTORY",
+			severity: "warn",
+			summary: message,
+			why: "The marker the database carries names no contract in the on-disk migration graph.",
+			meta: { space },
+			nextActions: [runCommandAction("Overwrite the marker if the database already matches the contract", "prisma-next db sign"), runCommandAction("Or push the current contract to the database", "prisma-next db update")]
+		}
+	};
+}
+function missingInvariantsFinding(inputs) {
+	const message = `missing invariant(s): ${inputs.missing.join(", ")}`;
+	return {
+		document: {
+			code: "MIGRATION.MISSING_INVARIANTS",
+			severity: "warn",
+			...ifDefined("ref", inputs.refName),
+			invariants: [...inputs.missing],
+			message
+		},
+		diagnostic: {
+			code: "MIGRATION.MISSING_INVARIANTS",
+			severity: "warn",
+			summary: message,
+			why: inputs.refName === void 0 ? "The database marker does not carry every invariant the target requires." : `The database marker does not carry every invariant \`${inputs.refName}\` requires.`,
+			nextActions: [runCommandAction("Apply the migrations that provide them", "prisma-next migrate")],
+			meta: {
+				invariants: [...inputs.missing],
+				...ifDefined("ref", inputs.refName)
+			}
+		}
+	};
+}
+const SHORT_HASH_LENGTH = 12;
+function shortDisplayHash(hash) {
+	return hash.slice(0, SHORT_HASH_LENGTH);
+}
+const NO_DATABASE_STATE = {
+	markersBySpace: /* @__PURE__ */ new Map(),
+	ledgersBySpace: /* @__PURE__ */ new Map()
+};
+async function readDatabaseState(inputs) {
+	const { client } = inputs;
+	try {
+		await client.connect(inputs.connection);
+		const markersBySpace = new Map(await client.readAllMarkers());
+		const ledgersBySpace = /* @__PURE__ */ new Map();
+		for (const spaceId of inputs.spaceIds) ledgersBySpace.set(spaceId, await client.readLedger(spaceId));
+		return ok({
+			markersBySpace,
+			ledgersBySpace
+		});
+	} catch (error) {
+		return notOk(normalizeError(CliStructuredError$1.is(error) ? error : errorUnexpected(error instanceof Error ? error.message : String(error), { why: `Failed to read database state: ${error instanceof Error ? error.message : String(error)}` })));
+	} finally {
+		await closeQuietly(client);
+	}
+}
+function buildNoPathSummary(args) {
+	const markerPart = args.markerHash !== void 0 ? `the database state (${shortDisplayHash(args.markerHash)})` : "the database state";
+	const targetShort = shortDisplayHash(args.targetHash);
+	if (!args.explicitTarget) return `No migration path from ${markerPart} to the application's contract (${targetShort}). Run \`prisma-next migration plan --name <name>\` to author one.`;
+	return `No migration path from ${markerPart} to ${args.refName !== void 0 ? `the target (${targetShort} via \`${args.refName}\`)` : `the target (${targetShort})`}. Run \`prisma-next migration plan --name <name>\` to author one, or pass \`--to <contract>\` to pick a reachable target.`;
+}
+function buildStatusHeadline(args) {
+	if (args.markerDiverged && args.markerHash !== void 0) return `Database marker ${shortDisplayHash(args.markerHash)} is not in the on-disk migration graph`;
+	if (args.pendingCount === 0) return "Up to date";
+	return `${args.pendingCount} pending — run \`prisma-next migrate --to ${shortDisplayHash(args.targetHash)}\``;
+}
+/**
+* One space's section: its heading, where more than one space is in scope, on
+* top of its tree. Heading and tree are one drawing so the heading stays a
+* bare label — a `summary` would put a status glyph in front of it.
+*/
+function sectionBlock(section) {
+	const heading = section.showHeading ? [[{
+		text: `${section.space}:`,
+		tone: "heading"
+	}]] : [];
+	const body = section.tree.length === 0 ? [[{
+		text: "(no migrations)",
+		tone: "muted"
+	}]] : toneDrawing(section.tree);
+	return {
+		kind: "drawing",
+		lines: [...heading, ...body]
+	};
+}
+function statusPresentations(inputs) {
+	const legend = inputs.legend;
+	return {
+		human: () => [
+			{
+				kind: "fields",
+				rail: true,
+				rows: [
+					{
+						label: "migrations",
+						value: inputs.migrationsDir
+					},
+					...inputs.database === void 0 ? [] : [{
+						label: "database",
+						value: inputs.database
+					}],
+					...inputs.ref === void 0 ? [] : [{
+						label: "ref",
+						value: inputs.ref
+					}],
+					...inputs.from === void 0 ? [] : [{
+						label: "from",
+						value: inputs.from
+					}],
+					...inputs.space === void 0 ? [] : [{
+						label: "space",
+						value: inputs.space
+					}]
+				]
+			},
+			...legend === void 0 ? [] : [{
+				kind: "drawing",
+				lines: toneDrawing(legend)
+			}],
+			...inputs.sections.map(sectionBlock),
+			inputs.headline
+		],
+		json: () => inputs.document
+	};
+}
+const migrationStatusCommand = defineOrmCommand({
+	help: {
+		summary: "Show migration path and pending status",
+		description: "Shows which migrations are pending between the database marker and the\ntarget contract. Requires a database connection. Pass --from for an\noffline path preview without a database. Use `migration graph` for\ntopology, `migration log` for history, and `migration list` for on-disk\nenumeration.",
+		examples: [
+			"migration status",
+			"migration status --db $DATABASE_URL",
+			"migration status --to production",
+			"migration status --from abc123 --to production",
+			"migration status --ascii",
+			"migration status --legend"
+		]
+	},
+	args: { flags: {
+		db: dbFlag,
+		space: flag.string({
+			brief: "Narrow output to a single contract space",
+			placeholder: "id"
+		}),
+		to: flag.string({
+			brief: "Target contract reference (hash, prefix, ref name, migration dir name, <dir>^, or ./path)",
+			placeholder: "contract"
+		}),
+		from: flag.string({
+			brief: "Origin contract reference; same grammar as --to. Supplying it switches to offline path computation",
+			placeholder: "contract"
+		}),
+		legend: flag.boolean({ brief: "Print a key for the tree glyphs and lane colors" }),
+		ascii: flag.boolean({ brief: "Use ASCII glyphs (pipe-friendly)" })
+	} },
+	needs: { config: ormConfigSection },
+	handler: async (args, ctx) => {
+		const migrationsDir = migrationsDirFor(ctx.config, ctx.cwd);
+		const dbConnection = args.flags.db ?? ctx.config.db?.connection;
+		const hasDriver = ctx.config.driver !== void 0;
+		const usingFromOverride = args.flags.from !== void 0;
+		if (!usingFromOverride) {
+			const missingDb = requireLiveDatabase({
+				dbConnection,
+				hasDriver,
+				why: "migration status needs a database connection to read the marker and ledger (or pass --from for an offline path preview)",
+				retryCommand: "prisma-next migration status --from <contract>"
+			});
+			if (missingDb !== null) return notOk(normalizeError(missingDb));
+		}
+		const refsResult = await readMigrationRefs(appRefsDirFor(ctx.config, ctx.cwd));
+		if (!refsResult.ok) return notOk(normalizeError(refsResult.failure));
+		const refs = refsResult.value;
+		const findings = [];
+		const loaded = await buildReadAggregate(ctx.config, { migrationsDir });
+		if (!loaded.ok) return notOk(normalizeError(loaded.failure));
+		const { aggregate, contractHash } = loaded.value;
+		const contractConfig = { contract: ifDefined("output", contractPathFor(ctx.config, ctx.cwd)) };
+		try {
+			await readContractEnvelope(contractConfig);
+		} catch (error) {
+			findings.push(contractUnreadableFinding(error instanceof Error ? error.message : "unknown error"));
+		}
+		if (await loadContractRawSafely(contractConfig) !== null) {
+			const corruption = refusePackageCorruptionOnAggregate(aggregate);
+			if (corruption) return notOk(normalizeError(corruption));
+		}
+		const appGraph = aggregate.app.graph();
+		let activeRefHash;
+		let activeRefName;
+		let activeRefEntry;
+		if (args.flags.to !== void 0) {
+			const resolved = resolveContractRef(args.flags.to, {
+				graph: appGraph,
+				refs
+			});
+			if (!resolved.ok) return notOk(normalizeError(resolved.failure));
+			activeRefHash = resolved.value.hash;
+			if (resolved.value.provenance.kind === "ref") {
+				activeRefName = resolved.value.provenance.refName;
+				activeRefEntry = refs[activeRefName];
+			}
+		}
+		let fromOverrideHash;
+		if (args.flags.from !== void 0) {
+			const resolved = resolveContractRef(args.flags.from, {
+				graph: appGraph,
+				refs
+			});
+			if (!resolved.ok) return notOk(normalizeError(resolved.failure));
+			fromOverrideHash = resolved.value.hash;
+		}
+		const listed = runMigrationList({
+			spaces: await migrationSpaceListEntriesFromAggregate(aggregate, migrationsDir),
+			...ifDefined("spaceFilter", args.flags.space)
+		});
+		if (!listed.ok) return notOk(normalizeError(listed.failure));
+		const scopedSpaces = listed.value.spaces;
+		const connects = dbConnection !== void 0 && hasDriver && !usingFromOverride;
+		let database = NO_DATABASE_STATE;
+		if (connects) {
+			const read = await readDatabaseState({
+				client: createControlClient({
+					family: ctx.config.family,
+					target: ctx.config.target,
+					adapter: ctx.config.adapter,
+					...ifDefined("driver", ctx.config.driver),
+					extensions: ctx.config.extensions ?? []
+				}),
+				connection: dbConnection,
+				spaceIds: scopedSpaces.map((entry) => entry.space)
+			});
+			if (!read.ok) return notOk(read.failure);
+			database = read.value;
+		}
+		const appMarker = database.markersBySpace.get(aggregate.app.spaceId);
+		if (activeRefEntry !== void 0 && activeRefEntry.invariants.length > 0 && connects) {
+			const unknown = refuseUnknownInvariants({
+				graph: appGraph,
+				markerInvariants: appMarker?.invariants ?? [],
+				refInvariants: activeRefEntry.invariants,
+				...ifDefined("refName", activeRefName)
+			});
+			if (unknown) return notOk(normalizeError(unknown));
+		}
+		const glyphMode = args.flags.ascii ? "ascii" : "unicode";
+		const styler = createToneMigrationListStyler();
+		const showSpaceHeadings = scopedSpaces.length > 1;
+		const statusSpaces = [];
+		const renderInputs = [];
+		const emptySpaces = [];
+		let divergedMarker;
+		let noPath;
+		let headlineTargetHash = activeRefHash ?? contractHash;
+		let totalPending = 0;
+		for (const entry of scopedSpaces) {
+			const space = aggregate.space(entry.space);
+			if (space === void 0) continue;
+			const graph = space.graph();
+			const spaceContractHash = space.contract().storage.storageHash;
+			const targetHash = activeRefHash ?? spaceContractHash;
+			if (entry.space === aggregate.app.spaceId) headlineTargetHash = targetHash;
+			const markerHash = usingFromOverride ? fromOverrideHash : database.markersBySpace.get(entry.space)?.storageHash;
+			const originHash = originHashForStatus(markerHash);
+			const markerInGraph = markerHash === void 0 || graph.nodes.has(markerHash) || markerHash === spaceContractHash;
+			if (connects && markerInGraph && originHash !== targetHash && noPath === void 0 && !hasMigrationPath(graph, originHash, targetHash)) noPath = {
+				markerHash,
+				targetHash
+			};
+			if (connects && markerHash !== void 0 && !markerInGraph) {
+				divergedMarker ??= {
+					space: entry.space,
+					markerHash
+				};
+				findings.push(markerNotInHistoryFinding(entry.space));
+			}
+			const ledger = database.ledgersBySpace.get(entry.space) ?? [];
+			const annotations = deriveStatusEdgeAnnotations({
+				graph,
+				targetHash,
+				originHash,
+				appliedMigrationHashes: connects ? appliedHashesFromLedger(ledger) : /* @__PURE__ */ new Set(),
+				showAppliedOverlay: connects
+			});
+			const migrations = entry.migrations.map((migration) => ({
+				...migration,
+				status: statusForMigrationHash(migration.hash, annotations)
+			}));
+			totalPending += migrations.filter((migration) => migration.status === "pending").length;
+			statusSpaces.push({
+				space: entry.space,
+				currentContract: markerHash ?? null,
+				targetContract: targetHash,
+				migrations
+			});
+			if (graph.nodes.size === 0) {
+				emptySpaces.push(entry.space);
+				continue;
+			}
+			renderInputs.push({
+				spaceId: entry.space,
+				graph,
+				migrations: entry.migrations,
+				liveContractHash: contractHash,
+				refsByHash: listRefsByContractHash(space),
+				statusOverlayByHash: annotations,
+				colorize: true,
+				glyphMode,
+				styler,
+				palette: TONE_MIGRATION_GRAPH_PALETTE,
+				isAppSpace: entry.space === aggregate.app.spaceId,
+				...connects && markerHash !== void 0 ? { dbHash: markerHash } : {}
+			});
+		}
+		const requiredInvariants = [...activeRefEntry?.invariants ?? []].sort();
+		if (connects && requiredInvariants.length > 0) {
+			const held = new Set(appMarker?.invariants ?? []);
+			const missing = requiredInvariants.filter((id) => !held.has(id));
+			if (missing.length > 0) {
+				findings.push(missingInvariantsFinding({
+					missing,
+					refName: activeRefName
+				}));
+				if (activeRefHash !== void 0) {
+					const unreachable = refuseMissingInvariantPath({
+						graph: appGraph,
+						originHash: originHashForStatus(appMarker?.storageHash),
+						targetHash: activeRefHash,
+						missing,
+						...ifDefined("refName", activeRefName)
+					});
+					if (unreachable) return notOk(normalizeError(unreachable));
+				}
+			}
+		}
+		const rendered = renderMigrationGraphSpaceTrees(renderInputs);
+		const treesBySpace = new Map(renderInputs.map((input, index) => [input.spaceId, rendered[index] ?? ""]));
+		const sections = scopedSpaces.map((entry) => {
+			const tree = treesBySpace.get(entry.space) ?? "";
+			return {
+				space: entry.space,
+				tree: showSpaceHeadings && tree.length > 0 ? indentMigrationGraphTreeBlock(tree, "  ") : tree,
+				showHeading: showSpaceHeadings
+			};
+		});
+		const summary = scopedSpaces.every((entry) => entry.migrations.length === 0) ? "No migrations found" : noPath !== void 0 ? buildNoPathSummary({
+			markerHash: noPath.markerHash,
+			targetHash: noPath.targetHash,
+			explicitTarget: args.flags.to !== void 0,
+			refName: activeRefName
+		}) : buildStatusHeadline({
+			pendingCount: totalPending,
+			targetHash: headlineTargetHash,
+			markerDiverged: divergedMarker !== void 0,
+			markerHash: divergedMarker?.markerHash
+		});
+		const diagnostics = findings.map((finding) => finding.diagnostic);
+		const document = {
+			ok: true,
+			spaces: statusSpaces,
+			summary,
+			diagnostics: findings.map((finding) => finding.document)
+		};
+		const alarming = divergedMarker !== void 0 || totalPending > 0 || noPath !== void 0;
+		return ok(ctx.present({
+			data: document,
+			diagnostics
+		}, statusPresentations({
+			document,
+			sections,
+			headline: {
+				kind: "summary",
+				status: alarming ? "warn" : "ok",
+				text: summary
+			},
+			migrationsDir: displayPath(migrationsDir, ctx.cwd),
+			database: connects && typeof dbConnection === "string" ? maskConnectionUrl(dbConnection) : void 0,
+			ref: activeRefName,
+			from: args.flags.from,
+			space: args.flags.space,
+			legend: args.flags.legend ? renderMigrationGraphLegend({
+				colorize: true,
+				glyphMode,
+				styler,
+				palette: TONE_MIGRATION_GRAPH_PALETTE
+			}) : void 0
+		})));
+	}
+});
 function deletePresentations(document) {
 	return {
 		human: () => [{
@@ -2224,26 +4164,58 @@ const ormCommandFamily = defineCommandFamily({
 		"contract infer": contractInferCommand,
 		"db init": dbInitCommand,
 		"db schema": dbSchemaCommand,
+		"db update": dbUpdateCommand,
 		format: formatCommand,
+		init: initCommand,
 		migrate: migrateCommand,
 		"migration graph": migrationGraphCommand,
 		"migration list": migrationListCommand,
 		"migration log": migrationLogCommand,
+		"migration new": migrationNewCommand,
+		"migration plan": migrationPlanCommand,
 		"migration show": migrationShowCommand,
+		"migration status": migrationStatusCommand,
 		"ref delete": refDeleteCommand,
 		"ref list": refListCommand,
 		"ref set": refSetCommand
 	},
 	docsBaseUrl: DOCS_BASE_URL,
-	redirects: [{
-		from: "migration apply",
-		replacement: "{bin} migrate --to <contract>",
-		reason: "Applying a migration is a move to a target contract, not a verb of its own."
-	}, {
-		from: "migration ref",
-		replacement: "{bin} ref set|list|delete",
-		reason: "Refs are managed by their own command, for every space rather than migrations alone."
-	}]
+	redirects: [
+		{
+			from: "migration apply",
+			replacement: "{bin} migrate --to <contract>",
+			reason: "Applying a migration is a move to a target contract, not a verb of its own."
+		},
+		{
+			from: "migration ref",
+			replacement: "{bin} ref set|list|delete",
+			reason: "Refs are managed by their own command, for every space rather than migrations alone."
+		},
+		{
+			from: "migration status",
+			flag: "graph",
+			replacement: "{bin} migration graph",
+			reason: "Topology is its own command rather than a mode of the status report."
+		},
+		{
+			from: "migration status",
+			flag: "all",
+			replacement: "{bin} migration log --db <url>",
+			reason: "Execution history is read from the database ledger, which is what migration log does."
+		},
+		{
+			from: "migration status",
+			flag: "limit",
+			replacement: "{bin} migration log --db <url>",
+			reason: "Execution history is read from the database ledger, which is what migration log does."
+		},
+		{
+			from: "migration status",
+			flag: "ref",
+			replacement: "{bin} migration status --to <contract>",
+			reason: "One flag names the target contract, whether it is a ref, a hash or a migration."
+		}
+	]
 });
 /** The file the ORM's loader reads when `--config` names none. */
 const ORM_CONFIG_FILENAME = "prisma-next.config.ts";