@prisma/orm-toolchain 8.0.0-rc.1-dev.46 → 8.0.0-rc.10

package/dist/cli.mjs

@@ -1,11 +1,14 @@
-import { r as getEmittedArtifactPaths } from "./exports-BCLg4CiV-05kuwcb0.mjs";
+import { r as getEmittedArtifactPaths } from "./exports-CE6OD63o-4Qpqr2W7.mjs";
+import { t as MigrationToolsError } from "./errors-SoLLYLtw-DMxVbVs9.mjs";
 import { t as EMPTY_CONTRACT_HASH } from "./constants-CM-w38DQ-Cz_EXbOc.mjs";
-import { c as spaceMigrationDirectory } from "./verify-contract-spaces-DhJTb0zM-B62maCfE.mjs";
-import { i as createScaffoldSpecifierResolver } from "./import-roots-CNFBPAT1.mjs";
-import { $ as loadContractRawSafely, A as errorMigrationPlanningFailed, At as statusForMigrationHash, C as errorDestructiveChanges, Ct as resolveRefAdvancementFields, D as errorLegendHumanOnly, Dt as runMigrationCheck, E as errorHashMismatch, F as errorTargetMigrationNotSupported, H as executeMigrateShowPlan, I as errorTargetMismatch, J as executeRefSetCommand, K as executeRefDeleteCommand, L as errorUnexpected, M as errorPathUnreachable, Mt as toDeclaredExtensionsFromRaw, N as errorRunnerFailed, O as errorMarkerMissing, Ot as runMigrationList, P as errorRuntime, Q as loadAggregateIntegrityViolations, R as executeContractEmit, S as errorDatabaseConnectionRequired, St as resolveMigrationRef, T as errorFileNotFound, Tt as runCommandAction, U as executeMigrationNewCommand, W as executeMigrationPlanCommand, X as hasMigrationPath, Y as findPackageByDirPath, Z as listRefsByContractHash, _ as enumerateCheckSpaces, _t as requireLiveDatabase, at as maskConnectionUrl, b as errorContractArgConflict, bt as resolveContractRefToSnapshot, ct as readContractEnvelope, d as closeQuietly, dt as refuseContractSpaceIntegrity, et as loadContractSpaceAggregateForCli, gt as refuseUnknownInvariants, ht as refusePackageCorruptionOnAggregate, i as appliedHashesFromLedger, j as errorNoMigrations, jt as targetSupportsMigrations, k as errorMigrationPackageNotFound, kt as sanitizeErrorMessage, l as checkSingleTarget, lt as readContractIR, m as deriveStatusEdgeAnnotations, mt as refuseMissingInvariantPath, n as advanceRefSafely, nt as mapCaughtMigrationError, o as buildMigrationSpaceGraphEntries, ot as migrationSpaceListEntriesFromAggregate, p as createControlClient, pt as refuseMarkerOutsideGraph, q as executeRefListCommand, rt as mapContractAtError, s as buildReadAggregate, st as originHashForStatus, t as CliStructuredError$1$1, tt as looksLikePath, u as chooseAction, ut as readMigrationRefs, v as errorConfigValidation$1, vt as resolveAppTargetPath, w as errorDriverRequired, x as errorContractValidationFailed, y as errorConsentPlanMismatch, yt as resolveContractRef$1 } from "./ref-h6InR6dO-rGfl18Jv.mjs";
-import { n as buildNextSteps, t as InitOutputSchema } from "./output-CovTDY14-CUoAqLML.mjs";
-import { r as loadConfig } from "./exports-BZaG8_w_.mjs";
+import { r as readRef } from "./refs-BpSpzdYB-BcDelHGt.mjs";
+import { c as spaceMigrationDirectory } from "./verify-contract-spaces-CrxvgpwD-D5LLXGci.mjs";
+import { i as createScaffoldSpecifierResolver } from "./import-roots-BHOrDJbI.mjs";
+import { $ as loadAggregateIntegrityViolations, A as errorMigrationPackageNotFound, At as runMigrationList, C as errorDatabaseConnectionRequired, D as errorHashMismatch, Dt as runCommandAction, E as errorFileNotFound, F as errorRuntime, G as executeMigrationPlanCommand, I as errorTargetMigrationNotSupported, J as executeRefListCommand, L as errorTargetMismatch, M as errorNoMigrations, Mt as statusForMigrationHash, N as errorPathUnreachable, Nt as targetSupportsMigrations, O as errorLegendHumanOnly, P as errorRunnerFailed, Pt as toDeclaredExtensionsFromRaw, Q as listRefsByContractHash, R as errorUnexpected, S as errorContractValidationFailed, St as resolveContractRefToSnapshot, T as errorDriverRequired, Tt as resolveRefAdvancementFields, U as executeMigrateShowPlan, W as executeMigrationNewCommand, X as findPackageByDirPath, Y as executeRefSetCommand, Z as hasMigrationPath, _ as enumerateCheckSpaces, _t as refusePackageCorruptionOnAggregate, b as errorConsentPlanMismatch, bt as resolveAppTargetPath, ct as originHashForStatus, d as closeQuietly, dt as readContractIR, et as loadContractRawSafely, ft as readMigrationRefs, gt as refuseMissingInvariantPath, ht as refuseMarkerOutsideGraph, i as appliedHashesFromLedger, it as mapContractAtError, j as errorMigrationPlanningFailed, jt as sanitizeErrorMessage, k as errorMarkerMissing, kt as runMigrationCheck, l as checkSingleTarget, lt as preflightRefAdvancement, m as deriveStatusEdgeAnnotations, n as advanceRefSafely, nt as looksLikePath, o as buildMigrationSpaceGraphEntries, ot as maskConnectionUrl, p as createControlClient, pt as refuseContractSpaceIntegrity, q as executeRefDeleteCommand, rt as mapCaughtMigrationError, s as buildReadAggregate, st as migrationSpaceListEntriesFromAggregate, t as CliStructuredError$1$1, tt as loadContractSpaceAggregateForCli, u as chooseAction, ut as readContractEnvelope, v as errorAdvanceRefArgConflict, vt as refuseUnknownInvariants, w as errorDestructiveChanges, wt as resolveMigrationRef, x as errorContractArgConflict, xt as resolveContractRef$1, y as errorConfigValidation$1, yt as requireLiveDatabase, z as executeContractEmit } from "./ref-DcqFmceq-QaUjgZeM.mjs";
+import { n as buildNextSteps, t as InitOutputSchema } from "./output-D83nTTpC-XlvN30yS.mjs";
+import { r as loadConfig, t as finalizeConfig } from "./exports-BXXeNWlj.mjs";
 import { createRequire } from "node:module";
+import { existsSync, mkdirSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
 import { DOCS_BASE, docsUrlFor, isStructuredError, isStructuredErrorCode } from "@prisma/orm-framework/utils/structured-error";
 import { keepInternalSpecifiers } from "@prisma/orm-framework/components/emission";
@@ -17,27 +20,26 @@ import { notOk, ok } from "@prisma/orm-framework/utils/result";
 import { basename, dirname, extname, isAbsolute, join, normalize, relative, resolve } from "pathe";
 import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { type } from "arktype";
-import { existsSync, mkdirSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
 import { defineCommand, defineCommandFamily, defineConfigSection, defineServerCommand, flag, positional } from "@prisma/cli-engine";
 import { CliStructuredError as CliStructuredError$1, notOk as notOk$1, ok as ok$1 } from "@prisma/cli-engine/protocol";
 import { collectConfigIssues } from "@prisma/orm-framework/config/config-validation";
+import { DEFAULT_CONTRACT_SOURCE_DIR } from "@prisma/orm-framework/config/config-types";
+import { pathToFileURL } from "node:url";
 import { printPsl } from "@prisma/orm-framework/psl-printer";
 import { EOL, tmpdir } from "node:os";
 import { format } from "@prisma/orm-framework/psl-parser/format";
-import { DEFAULT_CONTRACT_SOURCE_DIR } from "@prisma/orm-framework/config/config-types";
+import { suppressIdleConnectionErrors } from "@prisma/orm-framework/utils/suppress-idle-connection-errors";
 import { spawn } from "node:child_process";
 import { detect } from "package-manager-detector/detect";
 import { applyEdits, modify, parse, printParseErrorCode } from "jsonc-parser";
 import stringWidth from "string-width";
 import { bold, createColors, cyan, cyanBright, dim, green, yellow } from "colorette";
-import { pathToFileURL } from "node:url";
 import { build } from "esbuild";
-//#region ../../../1-framework/3-tooling/cli/dist/load-config-BQyCaOJz.mjs
-var version = "8.0.0-rc.1-dev.46";
+//#region ../../../1-framework/3-tooling/cli/dist/load-config-Dg1SXbzd.mjs
 const MISSING_CONFIG_ACTION = {
 	kind: "run-command",
 	label: "Create a config file",
-	command: "prisma-cli init"
+	command: "{bin} orm init"
 };
 function editConfigAction(field) {
 	return {
@@ -62,7 +64,7 @@ function sectionAbsentDiagnostic() {
 	return {
 		code: "CONFIG.FILE_NOT_FOUND",
 		severity: "error",
-		summary: "No Prisma Next configuration was loaded",
+		summary: "No Prisma ORM configuration was loaded",
 		why: `The orm config section is absent, so prisma.config.ts was never evaluated.`,
 		nextActions: [MISSING_CONFIG_ACTION]
 	};
@@ -71,7 +73,7 @@ function notAnObjectDiagnostic() {
 	return {
 		code: "CONFIG.VALIDATION_FAILED",
 		severity: "error",
-		summary: "Prisma Next configuration must be an object",
+		summary: "Prisma ORM configuration must be an object",
 		why: `The orm config section is not an object, so no section can be read from it.`,
 		nextActions: [{
 			kind: "edit-file",
@@ -83,7 +85,7 @@ function unreadableDiagnostic(error) {
 	return {
 		code: "CONFIG.VALIDATION_FAILED",
 		severity: "error",
-		summary: "Prisma Next configuration could not be inspected",
+		summary: "Prisma ORM configuration could not be inspected",
 		why: error instanceof Error ? error.message : String(error),
 		nextActions: [{
 			kind: "edit-file",
@@ -91,7 +93,7 @@ function unreadableDiagnostic(error) {
 		}]
 	};
 }
-function isRecord(value) {
+function isRecord$1(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 /**
@@ -101,10 +103,10 @@ function isRecord(value) {
 */
 function collectArtifactCollisionIssues(raw) {
 	const contract = raw["contract"];
-	if (!isRecord(contract)) return [];
+	if (!isRecord$1(contract)) return [];
 	const source = contract["source"];
 	const output = contract["output"];
-	if (!isRecord(source) || typeof output !== "string") return [];
+	if (!isRecord$1(source) || typeof output !== "string") return [];
 	const inputs = source["inputs"];
 	if (!Array.isArray(inputs)) return [];
 	let emitted;
@@ -130,7 +132,7 @@ function validate(raw) {
 		ok: false,
 		diagnostics: [sectionAbsentDiagnostic()]
 	};
-	if (!isRecord(raw)) return {
+	if (!isRecord$1(raw)) return {
 		ok: false,
 		diagnostics: [notAnObjectDiagnostic()]
 	};
@@ -246,15 +248,42 @@ function normalizeError(error) {
 *
 * An `InternalError` is the one thing this boundary does not convert. Its own contract says never
 * to catch it outside the outermost boundary: it means an invariant broke, which is a bug in
-* Prisma Next rather than something the user did. Re-throwing lets the engine settle it as a bug
+* Prisma ORM rather than something the user did. Re-throwing lets the engine settle it as a bug
 * at exit 1, where converting it would report the same number as a bad connection string.
 */
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Hands the handler a config whose paths are absolute. The engine's own
+* loader evaluates `prisma.config.ts` without touching the paths inside it, so
+* a command mounted in the unified host receives `contract.output` and
+* `migrations.dir` exactly as authored — usually relative — while this repo's
+* bin finalizes them in its loader. Anchoring here, on the section every ORM
+* command reads, makes both hosts hand handlers the same absolute paths.
+*
+* The anchor is the working directory: the engine discovers the config in the
+* working directory only, so that is the file's own directory. (A `--config`
+* pointing into another directory is not visible from a command context; a
+* relative path inside such a file resolves against the invocation directory,
+* which is also what the file's author sees the command run from.)
+* Finalization is idempotent — an already-absolute path resolves to itself —
+* so a config that arrived finalized passes through unchanged.
+*/
+function finalizedConfigContext(ctx) {
+	if (!isRecord(ctx.config)) return ctx;
+	const config = blindCast(ctx.config);
+	return {
+		...ctx,
+		config: finalizeConfig(config, ctx.cwd)
+	};
+}
 function defineOrmCommand(def) {
 	return defineCommand({
 		...def,
 		handler: async (args, ctx) => {
 			try {
-				return await def.handler(args, ctx);
+				return await def.handler(args, finalizedConfigContext(ctx));
 			} catch (error) {
 				if (isInternalError(error)) throw error;
 				return notOk$1(normalizeError(error));
@@ -574,7 +603,7 @@ function mapDbInitFailure(failure) {
 	if (failure.code === "PLANNING_FAILED") return errorMigrationPlanningFailed({ conflicts: failure.conflicts ?? [] });
 	if (failure.code === "MIGRATION.MARKER_ORIGIN_MISMATCH") return errorRuntime("MIGRATION.MARKER_ORIGIN_MISMATCH", `Existing database signature does not match plan destination.${markerMismatchDetail(failure)}`, {
 		why: "Database has an existing signature (marker) that does not match the target contract",
-		fix: "If bootstrapping, drop/reset the database then re-run `prisma-cli db init`; otherwise reconcile schema/marker using your migration workflow",
+		fix: "If bootstrapping, drop/reset the database then re-run `{bin} db init`; otherwise reconcile schema/marker using your migration workflow",
 		meta: {
 			...ifDefined("markerStorageHash", failure.marker?.storageHash),
 			...ifDefined("destinationStorageHash", failure.destination?.storageHash),
@@ -583,7 +612,7 @@ function mapDbInitFailure(failure) {
 		}
 	});
 	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-cli db init` to recreate it with the current per-space schema." : "Fix the schema mismatch (db init is additive-only), or drop/reset the database and re-run `prisma-cli db init`";
+		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 `{bin} db init` to recreate it with the current per-space schema." : "Fix the schema mismatch (db init is additive-only), or drop/reset the database and re-run `{bin} db init`";
 		return errorRunnerFailed(failure.summary, {
 			why: failure.why ?? "Migration runner failed",
 			fix,
@@ -818,7 +847,7 @@ function migrationResultBlocks(result) {
 }
 /** Where the user goes next, as typed actions rather than trailing prose. */
 function migrationResultNextActions(result, applyCommand) {
-	return result.mode === "plan" ? [runCommandAction("Apply the planned operations", applyCommand)] : [runCommandAction(result.perSpace !== void 0 && result.perSpace.length === 1 ? "Confirm the space is up to date" : "Confirm every space is up to date", "prisma-cli migration status")];
+	return result.mode === "plan" ? [runCommandAction("Apply the planned operations", applyCommand)] : [runCommandAction(result.perSpace !== void 0 && result.perSpace.length === 1 ? "Confirm the space is up to date" : "Confirm every space is up to date", "{bin} migration status")];
 }
 /**
 * Where migrations live for this project. Resolved against the invocation
@@ -873,7 +902,7 @@ async function readContractDocument(contractPath) {
 	} catch (error) {
 		return notOk$1(normalizeError(Reflect.get(Object(error), "code") === "ENOENT" ? errorFileNotFound(contractPath, {
 			why: `Contract file not found at ${contractPath}`,
-			fix: "Run `prisma-cli contract emit` to generate contract.json, or update `contract.output` in prisma.config.ts"
+			fix: "Run `{bin} contract emit` to generate contract.json, or update `contract.output` in prisma.config.ts"
 		}) : errorUnexpected(error instanceof Error ? error.message : String(error), { why: `Failed to read contract file: ${error instanceof Error ? error.message : String(error)}` })));
 	}
 	try {
@@ -939,7 +968,7 @@ function initPresentations$1(inputs) {
 			]
 		}, ...migrationResultBlocks(document)],
 		json: () => document,
-		next: () => migrationResultNextActions(document, "prisma-cli db init")
+		next: () => migrationResultNextActions(document, "{bin} db init")
 	};
 }
 function initDocument(inputs) {
@@ -1271,13 +1300,15 @@ async function readEmittedContract(inputs) {
 	} catch (error) {
 		return notOk$1(normalizeError(Reflect.get(Object(error), "code") === "ENOENT" ? errorFileNotFound(path, {
 			why: `Contract file not found at ${path}`,
-			fix: `Run \`prisma-cli contract emit\` to generate ${relativePath}, or update \`contract.output\` in prisma.config.ts`
+			fix: `Run \`{bin} contract emit\` to generate ${relativePath}, or update \`contract.output\` in prisma.config.ts`
 		}) : errorUnexpected(error instanceof Error ? error.message : String(error), { why: `Failed to read contract file: ${error instanceof Error ? error.message : String(error)}` })));
 	}
 	const familyInstance = inputs.config.family.create(createControlStack(inputs.config));
 	try {
+		const json = castAs(JSON.parse(content));
 		return ok$1({
-			contract: familyInstance.deserializeContract(castAs(JSON.parse(content))),
+			contract: familyInstance.deserializeContract(json),
+			json,
 			path,
 			displayPath: relativePath
 		});
@@ -1294,7 +1325,7 @@ function requireVerifyConnection(inputs) {
 	if (typeof dbConnection !== "string" || dbConnection.length === 0) return notOk$1(normalizeError(errorDatabaseConnectionRequired({
 		why: `Database connection is required for ${inputs.invocation} (set db.connection in prisma.config.ts, or pass --db <url>)`,
 		missingFlags: ["--db"],
-		retryCommand: `prisma-cli ${inputs.invocation} --db <url>`
+		retryCommand: `{bin} ${inputs.invocation} --db <url>`
 	})));
 	if (inputs.config.driver === void 0) return notOk$1(normalizeError(errorDriverRequired({ why: `Config.driver is required for ${inputs.invocation}` })));
 	return ok$1(dbConnection);
@@ -1429,6 +1460,30 @@ function schemaVerdictDiagnostic(inputs) {
 const FINDINGS_EXIT_CODE$2 = 4;
 /** The config file this bin reads; the handler is not told which one was loaded. */
 const CONFIG_DISPLAY_PATH = "prisma.config.ts";
+/**
+* The ref a signature checkpoints. Unlike `db init` / `db update`, `--db` does
+* not suppress the write: signing does not touch the schema, and adoption is
+* normally done against the real database via `--db`. Only `--no-advance-ref`
+* suppresses it.
+*/
+const DEFAULT_ADVANCE_REF = "db";
+const NO_PREVIOUS_HASH_CODES = /* @__PURE__ */ new Set([
+	"MIGRATION.UNKNOWN_REF",
+	"MIGRATION.INVALID_REF_FILE",
+	"MIGRATION.INVALID_REF_NAME"
+]);
+/**
+* The hash the ref held before the signature, read from that one ref file so a
+* corrupt sibling cannot fail a signature already written.
+*/
+async function previousRefHash(refsDir, name) {
+	try {
+		return (await readRef(refsDir, name)).hash;
+	} catch (error) {
+		if (MigrationToolsError.is(error) && NO_PREVIOUS_HASH_CODES.has(error.code)) return;
+		throw error;
+	}
+}
 function headerBlock$1(inputs) {
 	return {
 		kind: "fields",
@@ -1442,6 +1497,41 @@ function headerBlock$1(inputs) {
 		}]
 	};
 }
+function advancedRefSpans(advanced) {
+	return [
+		{ text: `Advanced ref "${advanced.name}" → ` },
+		{
+			text: advanced.hash,
+			tone: "identifier"
+		},
+		...advanced.previousHash === void 0 ? [] : [
+			{
+				text: " (was ",
+				tone: "muted"
+			},
+			{
+				text: advanced.previousHash,
+				tone: "identifier"
+			},
+			{
+				text: ")",
+				tone: "muted"
+			}
+		]
+	];
+}
+function refOutcomeBlock(advanced) {
+	return advanced === null ? {
+		kind: "summary",
+		status: "info",
+		tone: "muted",
+		text: `Left ref "${DEFAULT_ADVANCE_REF}" untouched (--no-advance-ref)`
+	} : {
+		kind: "summary",
+		status: "ok",
+		text: advancedRefSpans(advanced)
+	};
+}
 function signPresentations(inputs) {
 	const marker = inputs.document.marker;
 	return {
@@ -1472,7 +1562,8 @@ function signPresentations(inputs) {
 						tone: "identifier"
 					}]
 				}]
-			}
+			},
+			refOutcomeBlock(inputs.advanced)
 		],
 		json: () => inputs.document
 	};
@@ -1505,12 +1596,14 @@ function createDbSignCommand(createClient = createControlClient) {
 	return defineOrmCommand({
 		help: {
 			summary: "Sign the database with your contract so you can safely run queries",
-			description: "Verifies that your database schema satisfies the emitted contract, and if\nso, writes or updates the database signature. Idempotent and safe to run\nin CI or a deployment pipeline. The signature records that this database\ninstance is aligned with a specific contract version.\nExit codes: 0 = signed, 2 = the command could not run (unresolvable\ncontract reference, no emitted contract, unreachable database),\n4 = schema verification failed and no signature was written.",
+			description: "Verifies that your database schema satisfies the emitted contract, and if\nso, writes or updates the database signature. The signature records that\nthis database instance is aligned with a specific contract version.\nIdempotent. After signing, the db ref in the checkout is advanced to the\nsigned contract; pass --no-advance-ref to sign without touching any ref,\nwhich is what a CI or deployment pipeline usually wants.\nExit codes: 0 = signed, 2 = the command could not run (unresolvable\ncontract reference, no emitted contract, unreachable database),\n4 = schema verification failed and no signature was written.",
 			examples: [
 				"db sign",
 				"db sign --db $DATABASE_URL",
 				"db sign production --db $DATABASE_URL",
-				"db sign --contract production --db $DATABASE_URL"
+				"db sign --contract production --db $DATABASE_URL",
+				"db sign --db $DATABASE_URL --advance-ref production",
+				"db sign --db $DATABASE_URL --no-advance-ref"
 			]
 		},
 		args: {
@@ -1523,7 +1616,12 @@ function createDbSignCommand(createClient = createControlClient) {
 				contract: flag.string({
 					brief: "Contract reference (hash, prefix, ref name, migration dir name, <dir>^, or ./path)",
 					placeholder: "contract"
-				})
+				}),
+				advanceRef: flag.string({
+					brief: "Advance the named ref to the post-command contract hash",
+					placeholder: "name"
+				}),
+				noAdvanceRef: flag.boolean({ brief: "Sign without advancing any ref (no ref file or snapshot is written)" })
 			}
 		},
 		needs: { config: ormConfigSection },
@@ -1536,23 +1634,47 @@ function createDbSignCommand(createClient = createControlClient) {
 				flag: flagContract
 			})));
 			const contractRef = positionalContract ?? flagContract;
+			if (args.flags.noAdvanceRef && args.flags.advanceRef !== void 0) return notOk$1(normalizeError(errorAdvanceRefArgConflict({ advanceRef: args.flags.advanceRef })));
 			const emitted = await readEmittedContract({
 				config: ctx.config,
 				cwd: ctx.cwd,
 				commandName: "db sign"
 			});
 			if (!emitted.ok) return notOk$1(emitted.failure);
+			const migrationsDir = migrationsDirFor(ctx.config, ctx.cwd);
 			let contractInput = emitted.value.contract;
+			let signedSource;
 			if (contractRef !== void 0) {
 				const resolvedRef = await resolveContractRefToSnapshot({
 					config: ctx.config,
-					migrationsDir: migrationsDirFor(ctx.config, ctx.cwd),
+					migrationsDir,
 					refInput: contractRef,
 					contractPathAbsolute: emitted.value.path,
 					fallbackToEmitted: true
 				});
 				if (!resolvedRef.ok) return notOk$1(normalizeError(resolvedRef.failure));
 				contractInput = resolvedRef.value.contractJson;
+				signedSource = {
+					json: resolvedRef.value.contractJson,
+					jsonPath: resolvedRef.value.contractJsonPath
+				};
+			} else signedSource = {
+				json: emitted.value.json,
+				jsonPath: emitted.value.path
+			};
+			const refName = args.flags.noAdvanceRef ? null : args.flags.advanceRef ?? DEFAULT_ADVANCE_REF;
+			let advancement = null;
+			if (refName !== null) {
+				const preflight = await preflightRefAdvancement({
+					name: refName,
+					contractJson: signedSource.json,
+					contractJsonPath: signedSource.jsonPath
+				});
+				if (!preflight.ok) return notOk$1(normalizeError(preflight.failure));
+				advancement = {
+					name: refName,
+					contractIR: preflight.value
+				};
 			}
 			const connection = requireVerifyConnection({
 				config: ctx.config,
@@ -1588,7 +1710,7 @@ function createDbSignCommand(createClient = createControlClient) {
 						diagnostics: [schemaVerdictDiagnostic({
 							result: verified,
 							space: void 0,
-							nextActions: [runCommandAction("Bring the database up to the contract, then sign again", "prisma-cli db update")]
+							nextActions: [runCommandAction("Bring the database up to the contract, then sign again", "{bin} db update")]
 						})]
 					}, refusedPresentations({
 						document,
@@ -1602,11 +1724,43 @@ function createDbSignCommand(createClient = createControlClient) {
 					onProgress
 				});
 				if (!signed.ok) throw new InternalError(`The family returned a sign result that did not sign: ${signed.summary}`);
+				if (advancement === null) {
+					const document = {
+						...signed,
+						advancedRef: null
+					};
+					return ok$1(ctx.present({
+						data: document,
+						exitCode: 0
+					}, signPresentations({
+						document,
+						advanced: null,
+						header
+					})));
+				}
+				const refsDir = appRefsDirFor(ctx.config, ctx.cwd);
+				const previousHash = await previousRefHash(refsDir, advancement.name);
+				const advanced = await advanceRefSafely({
+					refsDir,
+					migrationsDir,
+					name: advancement.name,
+					hash: signed.contract.storageHash,
+					contractIR: advancement.contractIR
+				});
+				if (!advanced.ok) return notOk$1(normalizeError(advanced.failure));
+				const document = {
+					...signed,
+					advancedRef: advanced.value
+				};
 				return ok$1(ctx.present({
-					data: signed,
+					data: document,
 					exitCode: 0
 				}, signPresentations({
-					document: signed,
+					document,
+					advanced: {
+						...advanced.value,
+						previousHash
+					},
 					header
 				})));
 			} catch (error) {
@@ -1636,7 +1790,7 @@ const dbSignCommand = createDbSignCommand();
 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-cli db init` to recreate it with the current per-space schema." : "Inspect the reported conflict, reconcile schema drift if needed, then re-run `prisma-cli db update`";
+		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 `{bin} db init` to recreate it with the current per-space schema." : "Inspect the reported conflict, reconcile schema drift if needed, then re-run `{bin} db update`";
 		return errorRunnerFailed(failure.summary, {
 			why: failure.why ?? "Migration runner failed",
 			fix,
@@ -1649,7 +1803,7 @@ function mapDbUpdateFailure(failure) {
 	}
 	if (failure.code === "DESTRUCTIVE_CHANGES") return errorDestructiveChanges(failure.summary, {
 		...ifDefined("why", failure.why),
-		fix: "Re-run `prisma-cli 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.",
+		fix: "Re-run `{bin} 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,
@@ -1673,7 +1827,7 @@ function errorConsentTokenUnresolved(targetId) {
 		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-cli db update` again."
+			label: "Name the database in `db.connection` (or pass `--db <url>`) and run `{bin} db update` again."
 		}]
 	});
 }
@@ -1684,7 +1838,7 @@ function errorConsentOperationsMissing() {
 		nextActions: [{
 			kind: "run-command",
 			label: "Preview the plan",
-			command: "prisma-cli db update --dry-run"
+			command: "{bin} db update --dry-run"
 		}]
 	});
 }
@@ -1720,7 +1874,7 @@ function updatePresentations(inputs) {
 			]
 		}, ...migrationResultBlocks(document)],
 		json: () => document,
-		next: () => migrationResultNextActions(document, "prisma-cli db update")
+		next: () => migrationResultNextActions(document, "{bin} db update")
 	};
 }
 function updateDocument(inputs) {
@@ -1953,7 +2107,7 @@ function combineVerifyResults(perSpace, appSpaceId, strict, unclaimed) {
 * diagnostics rather than an error.
 */
 const FINDINGS_EXIT_CODE$1 = 4;
-const PUSH_THE_CONTRACT = runCommandAction("Push the contract to the database", "prisma-cli db update");
+const PUSH_THE_CONTRACT = runCommandAction("Push the contract to the database", "{bin} db update");
 const RECONCILE_BY_HAND = {
 	kind: "user-choice",
 	label: "Or reconcile the differences by hand and verify again"
@@ -2470,7 +2624,7 @@ function createFormatCommand(execute = executeFormat) {
 		help: {
 			summary: "Format your PSL contract source",
 			description: "Formats the Prisma schema (PSL) contract source declared in your config\n(contract.source.inputs[0]) in place. Only runs when contract.source.format\nis 'psl'; a TypeScript or unset source is left untouched. Indent and newline\nare read from the optional formatter config section, defaulting to two\nspaces and the system newline.",
-			examples: ["format", "format --json"]
+			examples: ["contract format", "contract format --json"]
 		},
 		needs: { config: ormConfigSection },
 		handler: async (_args, ctx) => {
@@ -2499,8 +2653,8 @@ const formatCommand = createFormatCommand();
 *
 * - We only inspect the unnamed top-level `catalog:` block. pnpm also
 *   supports `catalogs:` (plural — *named* catalogs referenced via
-*   `catalog:foo` specifiers); those don't apply to a vanilla
-*   `pnpm add prisma-next` invocation, so we skip them.
+*   `catalog:foo` specifiers); those don't apply to the vanilla
+*   `pnpm add` invocations `init` runs, so we skip them.
 * - We don't validate YAML syntax exhaustively. The file format pnpm
 *   ships is line-oriented and well-known; a minimal regex is more
 *   robust than depending on a YAML parser for one warning.
@@ -2615,7 +2769,7 @@ function errorInitMissingFlags(options) {
 	}).join(" ");
 	return new CliStructuredError$1$1("CLI.INIT_MISSING_FLAGS", "Missing required flags", {
 		why: `${options.why} Missing required flag(s): ${flagList}.`,
-		fix: `Re-run with the missing flag(s) supplied, e.g. \`prisma-cli init --yes ${fixList}\`. Use \`prisma-cli init --help\` to see every flag.`,
+		fix: `Re-run with the missing flag(s) supplied, e.g. \`prisma orm init --yes ${fixList}\`. Use \`prisma orm init --help\` to see every flag.`,
 		docsUrl: docsUrlFor("CLI.INIT_MISSING_FLAGS"),
 		meta: { missingFlags: options.missing }
 	});
@@ -2657,15 +2811,13 @@ function errorInitAuthoringSchemaPathMismatch(options) {
 }
 /**
 * The user cancelled an interactive prompt (Ctrl-C, escape, declined a
-* selection). Distinct from `errorInitReinitNeedsForce` because that path
-* applies to non-interactive mode where the user was never given the
-* choice; this one is the generic "user said no" path. Maps to exit code
+* selection) — the generic "user said no" path. Maps to exit code
 * 3 (USER_ABORTED).
 */
 function errorInitUserAborted() {
 	return new CliStructuredError$1$1("CLI.INIT_USER_ABORTED", "Init cancelled", {
 		why: "The interactive prompt was cancelled before all required inputs were supplied. No files were modified.",
-		fix: "Re-run `prisma-cli init` and complete the prompts, or pass the required inputs as flags (see `--help`) for a non-interactive run.",
+		fix: "Re-run `prisma orm init` and complete the prompts, or pass the required inputs as flags (see `--help`) for a non-interactive run.",
 		severity: "info"
 	});
 }
@@ -2698,7 +2850,7 @@ function errorInitStrictProbeWithoutProbe() {
 function errorInitInvalidManifest(options) {
 	return new CliStructuredError$1$1("CLI.INIT_INVALID_MANIFEST", `Failed to parse ${options.path}`, {
 		why: `\`${options.path}\` is not valid JSON: ${options.cause}`,
-		fix: `Fix the JSON syntax in \`${options.path}\` (a missing comma or unbalanced brace is the most common cause), then re-run \`prisma-cli init\`.`,
+		fix: `Fix the JSON syntax in \`${options.path}\` (a missing comma or unbalanced brace is the most common cause), then re-run \`prisma orm init\`.`,
 		docsUrl: docsUrlFor("CLI.INIT_INVALID_MANIFEST"),
 		meta: {
 			path: options.path,
@@ -2723,7 +2875,7 @@ function errorInitInvalidManifest(options) {
 function errorInitInvalidTsconfig(options) {
 	return new CliStructuredError$1$1("CLI.INIT_INVALID_TSCONFIG", `Failed to parse ${options.path}`, {
 		why: `\`${options.path}\` is not valid JSON or JSONC: ${options.cause}`,
-		fix: `Fix the syntax in \`${options.path}\` and re-run \`prisma-cli init\`. \`init\` accepts JSONC (comments and trailing commas) but cannot recover from unbalanced braces or missing commas.`,
+		fix: `Fix the syntax in \`${options.path}\` and re-run \`prisma orm init\`. \`init\` accepts JSONC (comments and trailing commas) but cannot recover from unbalanced braces or missing commas.`,
 		docsUrl: docsUrlFor("CLI.INIT_INVALID_TSCONFIG"),
 		meta: {
 			path: options.path,
@@ -2767,7 +2919,7 @@ function errorInitProbeFailed(options) {
 function errorInitWriteFailed(options) {
 	return new CliStructuredError$1$1("CLI.INIT_WRITE_FAILED", `Failed to write ${options.path}`, {
 		why: `\`${options.path}\` could not be written: ${options.cause}`,
-		fix: "Fix what stopped the write — a directory sitting where the file goes, permissions, a full disk — then run `prisma-cli init` again. It will ask you to confirm replacing the files this run already wrote (listed in `meta.filesWritten`).",
+		fix: "Fix what stopped the write — a directory sitting where the file goes, permissions, a full disk — then run `prisma orm init` again. Interactive runs ask before replacing the files this run already wrote (listed in `meta.filesWritten`); non-interactive runs grant that consent with `--confirm <directory name>`.",
 		docsUrl: docsUrlFor("CLI.INIT_WRITE_FAILED"),
 		meta: {
 			path: options.path,
@@ -2811,7 +2963,7 @@ async function probeServerVersion(ctx, overrides = {}) {
 			minVersion,
 			meetsMinimum: null,
 			cause: err.message,
-			message: `Skipped --probe-db: ${err.message}. (Run with install enabled, or install the driver yourself, then re-run \`prisma-cli init --probe-db\`.)`
+			message: `Skipped --probe-db: ${err.message}. (Run with install enabled, or install the driver yourself, then re-run \`prisma orm init --probe-db\`.)`
 		};
 		const cause = redactDatabaseUrlSecrets(causeMessage$2(err));
 		return {
@@ -2886,9 +3038,9 @@ function redactDatabaseUrlSecrets(text) {
 	return text.replace(/([a-zA-Z][a-zA-Z0-9+.-]*:\/\/)([^/@\s]+)@/g, "$1***@");
 }
 async function defaultProbePostgres(databaseUrl, baseDir, overrides) {
-	const client = new (requirePeer("pg", baseDir, overrides)).Client({ connectionString: databaseUrl });
-	await client.connect();
+	const client = suppressIdleConnectionErrors(new (requirePeer("pg", baseDir, overrides)).Client({ connectionString: databaseUrl }));
 	try {
+		await client.connect();
 		const result = await client.query("SELECT version() as version");
 		return { serverVersion: parsePostgresVersion(String(result?.rows?.[0]?.version ?? "")) };
 	} finally {
@@ -2942,168 +3094,6 @@ function requirePeer(moduleId, baseDir, overrides) {
 	}
 }
 /**
-* Default base for the GitHub-URL form `<owner>/<repo>` consumed by
-* upstream `skills add`. Each `SkillSource` joins this base with its
-* own subpath (and optional `#ref` for version-pinned clusters).
-*/
-const DEFAULT_SKILL_BASE = "prisma/prisma";
-const DEFAULT_SKILL_SOURCES = [
-	{
-		subpath: "skills",
-		skill: "prisma-8",
-		ref: "cli",
-		description: "usage skill (version-locked to installed Prisma Next)"
-	},
-	{
-		subpath: "skills",
-		skill: "prisma-next-upgrade",
-		ref: null,
-		description: "upgrade skill (always tracks `main`)"
-	},
-	{
-		subpath: "skills",
-		skill: "prisma-8-extension-upgrade",
-		ref: null,
-		description: "extension-author upgrade skill (always tracks `main`)"
-	}
-];
-/**
-* Test-only escape hatch for pinning the install base to a local
-* checkout. Production runs leave this unset, so installs always use
-* `DEFAULT_SKILL_BASE`.
-*
-* When set to an absolute filesystem path (typical for tests), the
-* `#ref` fragment is dropped — local-path mode in upstream's CLI does
-* not accept refs, and the local clone has whatever content the test
-* checked into it anyway. When set to anything else (e.g. a fork name
-* `myuser/prisma-next`), the ref policy is preserved.
-*/
-function resolveAgentSkillBase(env) {
-	const override = env["PRISMA_NEXT_SKILLS_BASE"]?.trim();
-	return override && override.length > 0 ? override : DEFAULT_SKILL_BASE;
-}
-function isLocalPath(base) {
-	return base.startsWith("/") || /^[a-zA-Z]:[\\/]/.test(base);
-}
-/**
-* Agents passed to every project-level init install. Upstream `skills add`
-* is the source of truth for per-agent install behaviour; the CLI lists
-* every supported runtime on one invocation and delegates the rest.
-*/
-const DEFAULT_SKILL_AGENTS = [
-	"cursor",
-	"claude-code",
-	"codex",
-	"windsurf"
-];
-/**
-* Build the `<base>/<subpath>[#ref]` URL the `skills` CLI will
-* resolve. Exported for unit tests so the per-source format can be
-* asserted without going through the full install loop.
-*/
-function formatSkillSourceUrl(source, env = process.env) {
-	const base = resolveAgentSkillBase(env);
-	const url = `${base}/${source.subpath}`;
-	if (source.ref === null) return url;
-	if (isLocalPath(base)) return url;
-	if (source.ref === "cli") return `${url}#v${version}`;
-	return url;
-}
-/**
-* The skill-install command for one source, formatted for the
-* project's detected package manager. `npx`/`pnpm dlx`/`bunx` are
-* interchangeable to the user; we pick the variant that matches the
-* rest of the install step so a single project consistently uses one
-* runner.
-*
-* `--agent` takes space-separated slugs on one flag; the explicit
-* `--skill <name>` and `-y` skip the multi-select prompts a
-* non-interactive scaffold step cannot show.
-*
-* Exported for unit tests so the per-PM dispatch can be asserted
-* without a live subprocess.
-*/
-function formatSkillInstallCommand(args) {
-	const agents = args.agents ?? DEFAULT_SKILL_AGENTS;
-	const cliArgs = [
-		"skills@latest",
-		"add",
-		formatSkillSourceUrl(args.source, args.env),
-		"--agent",
-		...agents,
-		"--skill",
-		args.source.skill,
-		"-y"
-	];
-	return formatPackageManagerCommand(args.pm, cliArgs);
-}
-/**
-* Ordered skill-install commands for one init run. This is both what the
-* commander shell runs and what either shell tells the user to run when the
-* install is skipped or fails — the commands need no scaffold and no `init`.
-*/
-function resolveProjectSkillInstallCommands(pm, env) {
-	return DEFAULT_SKILL_SOURCES.map((source) => formatSkillInstallCommand({
-		pm,
-		source,
-		...ifDefined("env", env)
-	}));
-}
-function formatPackageManagerCommand(pm, args) {
-	switch (pm) {
-		case "pnpm": return `pnpm dlx ${args.join(" ")}`;
-		case "yarn": return `yarn dlx ${args.join(" ")}`;
-		case "bun": return `bunx ${args.join(" ")}`;
-		case "deno": return `deno run -A npm:${args.join(" ")}`;
-		case "npm": return `npx ${args.join(" ")}`;
-	}
-}
-/**
-* Skill directories that predate the consolidated `prisma-8` skill:
-* the per-workflow usage cluster (including the renamed
-* `prisma-8-migration-review` spelling it briefly shipped under), the
-* pre-rename spellings of the consolidated skill and the
-* extension-author upgrade skill, and any hand-rolled `prisma-next`
-* stub. Projects initialised before the consolidation carry these as
-* sibling directories in each agent's install root; left in place
-* they compete with the current skills for activation, so init
-* removes them on every run.
-*/
-const RETIRED_SKILL_NAMES = [
-	"prisma-next",
-	"prisma-next-quickstart",
-	"prisma-next-contract",
-	"prisma-next-migrations",
-	"prisma-next-migration-review",
-	"prisma-8-migration-review",
-	"prisma-next-queries",
-	"prisma-next-runtime",
-	"prisma-next-build",
-	"prisma-next-supabase",
-	"prisma-next-debug",
-	"prisma-next-feedback",
-	"prisma-next-extension-upgrade"
-];
-/**
-* Project-level install roots the upstream `skills` CLI uses for the
-* agents in `DEFAULT_SKILL_AGENTS`: cursor and codex install into
-* `.agents/skills`, claude-code into `.claude/skills`, windsurf into
-* `.windsurf/skills`.
-*/
-const AGENT_SKILL_ROOTS = [
-	".agents/skills",
-	".claude/skills",
-	".windsurf/skills"
-];
-/**
-* Every directory a retired per-workflow skill may occupy in a
-* consumer project. Init deletes each (recursively) before running the
-* skill install.
-*/
-function legacySkillDirs() {
-	return AGENT_SKILL_ROOTS.flatMap((root) => RETIRED_SKILL_NAMES.map((name) => `${root}/${name}`));
-}
-/**
 * The resolver a scaffold for `target` is written against.
 *
 * A scaffold is always on the facade root: `init` writes an application around
@@ -3155,13 +3145,13 @@ function starterSchema(target, authoring, resolveImportSpecifier = keepInternalS
 	return target === "mongo" ? starterSchemaPslMongo() : starterSchemaPslPostgres();
 }
 /**
-* Renders a short authoring-appropriate schema sample (FR5.1) for embedding
-* in `prisma-next.md`. Returns a complete fenced markdown code block.
+* Renders a short authoring-appropriate schema sample for embedding in
+* `prisma-8.md`. Returns a complete fenced markdown code block.
 *
 * The sample intentionally shows just one model: it's illustrative, not
 * a substitute for the full scaffolded contract file. The TS samples use
-* the same outer shape as `starterSchemaTs*` (FR5.3) so a user reading
-* the doc and the file side-by-side sees the same structure.
+* the same outer shape as `starterSchemaTs*` so a user reading the doc and
+* the file side-by-side sees the same structure.
 */
 function schemaSample(target, authoring, resolveImportSpecifier = keepInternalSpecifiers) {
 	if (authoring === "typescript") {
@@ -3235,7 +3225,7 @@ export const contract = defineContract(
 \`\`\``;
 }
 function starterSchemaPslPostgres() {
-	return `// use prisma-next
+	return `// use prisma-8
 
 model User {
   id        Int      @id @default(autoincrement())
@@ -3243,8 +3233,8 @@ model User {
   username  String?
   name      String?
   posts     Post[]
-  createdAt DateTime @default(now())
-  updatedAt temporal.updatedAt()
+  createdAt TimestamptzString @default(now())
+  updatedAt temporal.updatedAtString()
 }
 
 model Post {
@@ -3253,13 +3243,13 @@ model Post {
   content   String?
   author    User     @relation(fields: [authorId], references: [id])
   authorId  Int
-  createdAt DateTime @default(now())
-  updatedAt temporal.updatedAt()
+  createdAt TimestamptzString @default(now())
+  updatedAt temporal.updatedAtString()
 }
 `;
 }
 function starterSchemaPslMongo() {
-	return `// use prisma-next
+	return `// use prisma-8
 
 model User {
   id       ObjectId @id @map("_id")
@@ -3283,40 +3273,40 @@ model Post {
 function starterSchemaTsPostgres(builder) {
 	return `import { defineContract } from '${builder}';
 
-export const contract = defineContract(
-  {},
-  ({ field, model, rel }) => ({
+export const contract = defineContract({}, ({ field, model, rel }) => {
+  const User = model('User', {
+    fields: {
+      id: field.id.uuidv7String(),
+      email: field.text().unique(),
+      username: field.text().optional(),
+      name: field.text().optional(),
+      createdAt: field.temporal.createdAtString(),
+      updatedAt: field.temporal.updatedAtString(),
+    },
+  });
+
+  const Post = model('Post', {
+    fields: {
+      id: field.id.uuidv7String(),
+      title: field.text(),
+      content: field.text().optional(),
+      authorId: field.uuidString(),
+      createdAt: field.temporal.createdAtString(),
+      updatedAt: field.temporal.updatedAtString(),
+    },
+  });
+
+  return {
     models: {
-      User: model('User', {
-        fields: {
-          id: field.id.uuidv7String(),
-          email: field.text().unique(),
-          username: field.text().optional(),
-          name: field.text().optional(),
-          createdAt: field.temporal.createdAt(),
-          updatedAt: field.temporal.updatedAt(),
-        },
-        relations: {
-          posts: rel.hasMany('Post', { by: 'authorId' }),
-        },
+      User: User.relations({
+        posts: rel.hasMany(Post, { by: 'authorId' }),
       }),
-
-      Post: model('Post', {
-        fields: {
-          id: field.id.uuidv7String(),
-          title: field.text(),
-          content: field.text().optional(),
-          authorId: field.uuidString(),
-          createdAt: field.temporal.createdAt(),
-          updatedAt: field.temporal.updatedAt(),
-        },
-        relations: {
-          author: rel.belongsTo('User', { from: 'authorId', to: 'id' }),
-        },
+      Post: Post.relations({
+        author: rel.belongsTo(User, { from: 'authorId', to: 'id' }),
       }),
     },
-  }),
-);
+  };
+});
 `;
 }
 function starterSchemaTsMongo(builder) {
@@ -3358,10 +3348,10 @@ export const contract = defineContract(
 }
 function configFile(target, contractPath, resolveImportSpecifier = keepInternalSpecifiers) {
 	return `import 'dotenv/config';
-import { defineConfig } from '@prisma/cli-engine';
+import { definePrismaConfig } from '@prisma/cli-engine';
 import { defineConfig as ormConfig } from '${targetEntrypoint(target, "config", resolveImportSpecifier)}';
 
-export default defineConfig({
+export default definePrismaConfig({
   orm: ormConfig({
     contract: ${JSON.stringify(contractPath)},
     db: {
@@ -3373,7 +3363,8 @@ export default defineConfig({
 }
 function dbFile(target, resolveImportSpecifier = keepInternalSpecifiers) {
 	const runtime = targetEntrypoint(target, "runtime", resolveImportSpecifier);
-	if (target === "postgres") return `import postgres from '${runtime}';
+	if (target === "postgres") return `import 'dotenv/config';
+import postgres from '${runtime}';
 import type { Contract } from './contract.d';
 import contractJson from './contract.json' with { type: 'json' };
 
@@ -3382,7 +3373,8 @@ export const db = postgres<Contract>({
   url: process.env['DATABASE_URL']!,
 });
 `;
-	return `import mongo from '${runtime}';
+	return `import 'dotenv/config';
+import mongo from '${runtime}';
 import type { Contract } from './contract.d';
 import contractJson from './contract.json' with { type: 'json' };
 
@@ -3402,7 +3394,7 @@ export const db = mongo<Contract>({
 * Bumping a value here in isolation is **not** safe: edit the
 * corresponding target package's `package.json` first, then mirror
 * here. The scaffold's `.env.example` and the "Requirements" section
-* of `prisma-next.md` both read from this constant, so a stale value
+* of `prisma-8.md` both read from this constant, so a stale value
 * lies to every freshly initialised user.
 */
 const MIN_SERVER_VERSION = {
@@ -3466,7 +3458,7 @@ function envFileContent(target) {
 	return envPlaceholderBody(target);
 }
 /** The invocation that finishes what a failed `init` phase started. */
-const EMIT_COMMAND = "prisma-cli contract emit";
+const EMIT_COMMAND = "prisma contract emit";
 /**
 * 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
@@ -3510,22 +3502,6 @@ function emitFailedFinding(cause, filesWritten) {
 		}
 	});
 }
-/**
-* 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,
@@ -3569,11 +3545,11 @@ function buildInitNextActions(inputs) {
 		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"));
+	actions.push(chooseAction("Open prisma-8.md for a quick reference on writing your first typed query"));
+	actions.push(runCommandAction("Set up the Prisma agent skills for your coding agent", "prisma init"));
 	return actions;
 }
-const DONE_TEXT = "Done. Open prisma-next.md to get started.";
+const DONE_TEXT = "Done. Open prisma-8.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
@@ -3634,7 +3610,7 @@ function redactSecrets(stderr) {
 }
 /**
 * Emits the contract for the project `init` has just scaffolded, by spawning
-* the project-local `prisma-cli` binary the install step put into
+* the project-local `prisma` binary the install step put into
 * `node_modules`. That binary and the installed `defineConfig` come from the
 * same registry release, so the config loader that evaluates
 * `prisma.config.ts` always matches the config format it was written
@@ -3652,26 +3628,26 @@ async function emitScaffoldedContract(ctx, overrides = {}) {
 	if (result.exitCode !== 0) {
 		const output = result.stderr.trim().length > 0 ? result.stderr : result.stdout;
 		const cause = result.exitCode === null ? `was killed by signal ${result.signal ?? "unknown"}` : `exited with code ${result.exitCode}`;
-		throw new Error(`\`prisma-cli contract emit\` ${cause}: ${redactSecrets(tail(output))}`);
+		throw new Error(`\`prisma contract emit\` ${cause}: ${redactSecrets(tail(output))}`);
 	}
 }
 function resolveProjectBin(cwd, overrides) {
 	const resolveFromBaseDir = overrides.resolveFromBaseDir ?? ((baseDir, specifier) => createRequire(join(baseDir, "package.json")).resolve(specifier));
 	let manifestPath;
 	try {
-		manifestPath = resolveFromBaseDir(cwd, "@prisma/cli/package.json");
+		manifestPath = resolveFromBaseDir(cwd, "prisma/package.json");
 	} catch (error) {
-		throw new Error(`\`@prisma/cli\` is not installed in this project (resolved from ${cwd}; cause: ${causeMessage$1(error)})`);
+		throw new Error(`\`prisma\` is not installed in this project (resolved from ${cwd}; cause: ${causeMessage$1(error)})`);
 	}
 	let manifest;
 	try {
 		manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
 	} catch (error) {
-		throw new Error(`the installed @prisma/cli manifest at ${manifestPath} is not valid JSON: ${causeMessage$1(error)}`);
+		throw new Error(`the installed prisma manifest at ${manifestPath} is not valid JSON: ${causeMessage$1(error)}`);
 	}
 	const bin = manifest !== null && typeof manifest === "object" ? Reflect.get(manifest, "bin") : void 0;
-	const binEntry = typeof bin === "string" ? bin : bin !== null && typeof bin === "object" ? Reflect.get(bin, "prisma-cli") : void 0;
-	if (typeof binEntry !== "string") throw new Error(`the installed @prisma/cli package at ${dirname(manifestPath)} declares no \`prisma-cli\` bin`);
+	const binEntry = typeof bin === "string" ? bin : bin !== null && typeof bin === "object" ? Reflect.get(bin, "prisma") : void 0;
+	if (typeof binEntry !== "string") throw new Error(`the installed prisma package at ${dirname(manifestPath)} declares no \`prisma\` bin`);
 	return join(dirname(manifestPath), binEntry);
 }
 function runCaptured(file, args, cwd) {
@@ -3693,7 +3669,7 @@ function runCaptured(file, args, cwd) {
 			stderr += chunk.toString("utf-8");
 		});
 		child.on("error", (error) => {
-			reject(/* @__PURE__ */ new Error(`could not run the project-local prisma-cli binary: ${error.message}`));
+			reject(/* @__PURE__ */ new Error(`could not run the project-local prisma binary: ${error.message}`));
 		});
 		child.on("close", (code, signal) => {
 			resolve({
@@ -3791,7 +3767,7 @@ function formatRunScriptCommand(pm, scriptName) {
 * [`.gitattributes`](../../../../../../../../.gitattributes):
 *
 * - **Today**: `contract.json`, `contract.d.ts` are emitted on every
-*   `prisma-cli contract emit`. Marking them `linguist-generated`
+*   `prisma contract emit`. Marking them `linguist-generated`
 *   keeps GitHub's diff stats honest and collapses the file in code
 *   review by default.
 * - **Forward-looking**: `ops.json`, `migration.json` are not yet emitted
@@ -3863,7 +3839,7 @@ function mergeGitattributes(existing, required) {
 	return `${existing}${existing.length === 0 || existing.endsWith("\n") ? "" : "\n"}${missing.join("\n")}\n`;
 }
 /**
-* The minimal `.gitignore` lines a Prisma Next scaffold needs (FR3.3).
+* The minimal `.gitignore` lines a Prisma ORM scaffold needs (FR3.3).
 * Order matches what Node tooling typically writes today.
 *
 * `node_modules/` first because it's the byte-largest miss; `dist/`
@@ -3902,7 +3878,7 @@ function mergeGitignore(existing) {
 }
 const REQUIRED_SCRIPTS = [{
 	name: "contract:emit",
-	command: "prisma-cli contract emit"
+	command: "prisma contract emit"
 }];
 /**
 * Idempotent `package.json#scripts` merge with collision detection
@@ -3937,7 +3913,7 @@ function mergePackageScripts(existing, required = REQUIRED_SCRIPTS) {
 			mutated = true;
 			continue;
 		}
-		if (existingValue !== command) warnings.push(`package.json already has a "${name}" script with a different command — keeping yours.\n  existing: ${existingValue}\n  expected: ${command}\nIf you want the default, remove your "${name}" script and re-run \`init\`.`);
+		if (existingValue !== command) warnings.push(`package.json already has a "${name}" script with a different command — keeping yours.\n  existing: ${existingValue}\n  expected: ${command}\nIf you want the default, remove your "${name}" script and re-run \`orm init\`.`);
 	}
 	if (!mutated) return {
 		content: null,
@@ -4073,6 +4049,51 @@ function removeDependency(existing, depName) {
 	const trailingNewline = existing.endsWith("\n") ? "\n" : "";
 	return `${JSON.stringify(parsed, null, 2)}${trailingNewline}`;
 }
+/**
+* Skill directories that predate the consolidated `prisma-8` skill: the
+* per-workflow usage cluster (including the renamed
+* `prisma-8-migration-review` spelling it briefly shipped under), the
+* pre-rename spellings of the consolidated skill and the extension-author
+* upgrade skill, any hand-rolled `prisma-next` stub, and the two standalone
+* upgrade skills that folded into the `prisma-8` router. Projects initialised
+* before those changes carry these as sibling directories in each agent's
+* install root; left in place they compete with the current skill for
+* activation, so init removes them on every run.
+*/
+const RETIRED_SKILL_NAMES = [
+	"prisma-next",
+	"prisma-next-quickstart",
+	"prisma-next-contract",
+	"prisma-next-migrations",
+	"prisma-next-migration-review",
+	"prisma-8-migration-review",
+	"prisma-next-queries",
+	"prisma-next-runtime",
+	"prisma-next-build",
+	"prisma-next-supabase",
+	"prisma-next-debug",
+	"prisma-next-feedback",
+	"prisma-next-extension-upgrade",
+	"prisma-next-upgrade",
+	"prisma-8-extension-upgrade"
+];
+/**
+* The project-level skill directories the agent harnesses read: Claude Code,
+* Cursor, Codex (`.agents`), and Windsurf.
+*/
+const AGENT_SKILL_ROOTS = [
+	".claude/skills",
+	".cursor/skills",
+	".agents/skills",
+	".windsurf/skills"
+];
+/**
+* Every directory a retired skill may occupy in a consumer project. Init
+* deletes each (recursively) on every run.
+*/
+function legacySkillDirs() {
+	return AGENT_SKILL_ROOTS.flatMap((root) => RETIRED_SKILL_NAMES.map((name) => `${root}/${name}`));
+}
 function renderTemplate(templateFile, variableNames, vars) {
 	let result = readFileSync(join(import.meta.dirname, templateFile), "utf-8");
 	for (const key of variableNames) {
@@ -4103,12 +4124,12 @@ function quickReferenceMd(target, authoring, schemaPath, pkgRun, resolveImportSp
 		pkg,
 		configEntrypoint: targetEntrypoint(target, "config", resolveImportSpecifier),
 		schemaSample: schemaSample(target, authoring, resolveImportSpecifier),
-		requirements: requirementsBlock(target)
+		requirements: requirementsBlock(target, pkgRun)
 	};
 	return renderTemplate(`quick-reference-${target}.md`, variables, vars);
 }
 /**
-* Renders the FR8.2 "Requirements" block injected into `prisma-next.md`
+* Renders the FR8.2 "Requirements" block injected into `prisma-8.md`
 * (the user-facing quick reference). Sources the minimum server
 * version from `MIN_SERVER_VERSION` — itself mirrored from each
 * target package's `package.json#prismaNext.minServerVersion`
@@ -4118,12 +4139,12 @@ function quickReferenceMd(target, authoring, schemaPath, pkgRun, resolveImportSp
 * shouldn't ship Mongo's `db.runCommand` (and vice versa) just because
 * we couldn't be bothered to branch.
 */
-function requirementsBlock(target) {
+function requirementsBlock(target, pkgRun) {
 	return [
 		"## Requirements",
 		"",
 		`- **${TARGET_LABEL[target]} ${MIN_SERVER_VERSION[target]} or newer.** Older servers are not supported. Run ${target === "postgres" ? "`SELECT version()`" : "`db.runCommand({ buildInfo: 1 })`"} against your server to verify.`,
-		"- The CLI never connects to your database without explicit consent. Pass `--probe-db` to `prisma-cli init` if you want `init` to verify the server version itself."
+		`- The CLI never connects to your database without explicit consent. Pass \`--probe-db\` to \`${pkgRun} orm init\` if you want \`init\` to verify the server version itself.`
 	].join("\n");
 }
 const sharedVariables = [
@@ -4317,7 +4338,7 @@ function mergeTypesArray(existing) {
 	return result;
 }
 const CONFIG_FILE = "prisma.config.ts";
-const QUICK_REFERENCE_FILE = "prisma-next.md";
+const QUICK_REFERENCE_FILE = "prisma-8.md";
 const ENV_EXAMPLE_FILE = ".env.example";
 /**
 * The generated files a run replaces outright, in the order it writes them.
@@ -4326,7 +4347,7 @@ const ENV_EXAMPLE_FILE = ".env.example";
 * 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
+* conventional filename in projects that have never seen Prisma ORM, and a
 * consent token demanded for it would fire on first runs. The scaffold warns
 * when it replaces one instead.
 */
@@ -4408,7 +4429,7 @@ function planScaffold(ctx) {
 	const warnings = [];
 	const schemaDir = dirname(inputs.schemaPath);
 	const configContractPath = isAbsolute(inputs.schemaPath) ? inputs.schemaPath : `./${inputs.schemaPath}`;
-	const runPrefix = formatRunCommand(packageManager, "prisma-cli", "").trimEnd();
+	const runPrefix = formatRunCommand(packageManager, "prisma", "").trimEnd();
 	const files = [
 		{
 			path: inputs.schemaPath,
@@ -4431,7 +4452,7 @@ function planScaffold(ctx) {
 			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.`);
+	if (existsSync(join(cwd, ENV_EXAMPLE_FILE))) warnings.push(`${ENV_EXAMPLE_FILE} already existed and was replaced with the Prisma ORM 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.");
@@ -4497,7 +4518,7 @@ function planScaffold(ctx) {
 				changed = true;
 			}
 		}
-		const { content: withScripts, warnings: scriptWarnings } = mergePackageScripts(working, REQUIRED_SCRIPTS);
+		const { content: withScripts, warnings: scriptWarnings } = mergePackageScripts(working);
 		if (withScripts !== null) {
 			working = withScripts;
 			changed = true;
@@ -4728,8 +4749,7 @@ async function resolveInitInputs(ctx) {
 		probeDb: flags.probeDb,
 		strictProbe: flags.strictProbe,
 		reinit,
-		removePreviousFacade,
-		installProjectSkill: !flags.skipSkills
+		removePreviousFacade
 	};
 }
 /**
@@ -4770,7 +4790,7 @@ function pnpmLeakedASpecifier(failure) {
 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.",
+		"pnpm could not install: a published Prisma ORM 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.",
@@ -4788,6 +4808,28 @@ function retriedWarning(failure) {
 * command, and this decides — from the stderr it returned — that another
 * manager is worth a try.
 */
+/**
+* The engine dependency spec a fresh scaffold installs. The scaffolded
+* `prisma.config.ts` imports `defineConfig` from `@prisma/cli-engine`, and the
+* installed `prisma` names the exact engine version it runs against — so
+* the spec is read from the manifest the install just placed, never guessed
+* from a dist-tag (whose `latest` has lagged that version before and broken
+* the very next command). A CLI without a readable engine entry falls back to
+* the `next` tag, the release train the CLI itself publishes under.
+*/
+function engineDevDependencySpec(cwd) {
+	try {
+		const manifest = JSON.parse(readFileSync(join(cwd, "node_modules", "prisma", "package.json"), "utf-8"));
+		if (typeof manifest === "object" && manifest !== null) for (const field of ["dependencies", "peerDependencies"]) {
+			const block = Reflect.get(manifest, field);
+			if (typeof block === "object" && block !== null) {
+				const engine = Reflect.get(block, "@prisma/cli-engine");
+				if (typeof engine === "string" && engine.length > 0) return `@prisma/cli-engine@${engine}`;
+			}
+		}
+	} catch {}
+	return "@prisma/cli-engine@latest";
+}
 async function installProjectDependencies(ctx) {
 	const pair = async (manager) => {
 		const runtimeDeps = await ctx.packages.install({
@@ -4827,38 +4869,10 @@ async function installProjectDependencies(ctx) {
 		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"
+	5: "scaffold written and installed; contract emit failed"
 };
 function probeWarning(outcome, strictProbe) {
 	switch (outcome.kind) {
@@ -4886,15 +4900,14 @@ function causeMessage(error) {
 }
 const createInitCommand = (injected) => defineOrmCommand({
 	help: {
-		summary: "Initialize a new Prisma Next project",
+		summary: "Initialize a new Prisma ORM 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"
+			"orm init",
+			"orm init --target postgres --authoring psl",
+			"orm init --target mongodb --authoring typescript --json",
+			"orm init --skip-install",
+			"orm init --target postgres --keep-previous-facade"
 		]
 	},
 	args: { flags: {
@@ -4914,7 +4927,6 @@ const createInitCommand = (injected) => defineOrmCommand({
 		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,
@@ -4950,14 +4962,12 @@ const createInitCommand = (injected) => defineOrmCommand({
 			text: note
 		});
 		const deps = [targetPackageName(inputs.target, scaffold.resolveImportSpecifier), "dotenv"];
-		const cliDevDeps = ["@prisma/cli@next", "@prisma/cli-engine"];
+		const cliDevDeps = ["prisma@latest"];
 		const devDeps = scaffold.hasTypesNode ? cliDevDeps : [...cliDevDeps, "@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 = {
@@ -4978,15 +4988,14 @@ const createInitCommand = (injected) => defineOrmCommand({
 					packagesInstalled,
 					contractEmitted,
 					emitCommand: EMIT_COMMAND,
-					schemaPath: inputs.schemaPath,
-					skillRegistered
+					schemaPath: inputs.schemaPath
 				}),
 				warnings
 			};
 			const validated = InitOutputSchema(document);
 			if (validated instanceof type.errors) return notOk$1(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.")],
+				nextActions: [chooseAction("This is a bug in Prisma ORM. Please report it with `-v` output.")],
 				docsUrl: docsUrlFor("CLI.INIT_INVALID_OUTPUT_DOCUMENT")
 			}));
 			return ok$1(ctx.present({
@@ -4998,8 +5007,7 @@ const createInitCommand = (injected) => defineOrmCommand({
 				complete: exitCode === 0,
 				nextActions: [...extraActions, ...buildInitNextActions({
 					contractEmitted,
-					schemaPath: inputs.schemaPath,
-					skillRegistered
+					schemaPath: inputs.schemaPath
 				})]
 			})));
 		};
@@ -5017,8 +5025,20 @@ const createInitCommand = (injected) => defineOrmCommand({
 				findings.push(installFailedFinding(outcome.failure, scaffold.filesWritten));
 				return settle(4);
 			}
+			const engineSpec = engineDevDependencySpec(ctx.cwd);
+			const engineInstall = await ctx.packages.install({
+				packages: [engineSpec],
+				dev: true,
+				cwd: ctx.cwd,
+				...ifDefined("manager", outcome.manager)
+			});
+			if (!engineInstall.ok) {
+				packagesInstalled = "failed";
+				findings.push(installFailedFinding(engineInstall.failure, scaffold.filesWritten));
+				return settle(4);
+			}
+			devDeps.push(engineSpec);
 			packagesInstalled = "installed";
-			installedManager = outcome.manager;
 			const emitStep = "Emit the contract";
 			ctx.report({
 				kind: "step-started",
@@ -5041,7 +5061,7 @@ const createInitCommand = (injected) => defineOrmCommand({
 				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)`));
+		} else extraActions.push(chooseAction(`Install the project dependencies with your package manager: ${deps.join(", ")} (and ${devDeps.join(", ")} plus @prisma/cli-engine at the version prisma declares as its dependency, as development dependencies)`));
 		if (inputs.probeDb) {
 			const probe = probeWarning(await probeServerVersion({
 				baseDir: ctx.cwd,
@@ -5055,20 +5075,6 @@ const createInitCommand = (injected) => defineOrmCommand({
 				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);
 	}
 });
@@ -5087,8 +5093,8 @@ function signalExitCode(reason) {
 }
 const lspCommand = defineServerCommand({
 	help: {
-		summary: "Start the Prisma Next language server",
-		description: "Launches a Language Server Protocol server that publishes PSL parse diagnostics\nand handles whole-document PSL formatting for the schema inputs declared in\nyour config (contract.source.inputs). Formatting uses the Prisma Next PSL\nformatter and the formatter block from the project config.\nCommunicates over stdio; intended to be spawned by an\neditor, not run interactively. The server keeps running until the editor client\ndisconnects.",
+		summary: "Start the Prisma ORM language server",
+		description: "Launches a Language Server Protocol server that publishes PSL parse diagnostics\nand handles whole-document PSL formatting for the schema inputs declared in\nyour config (contract.source.inputs). Formatting uses the Prisma ORM PSL\nformatter and the formatter block from the project config.\nCommunicates over stdio; intended to be spawned by an\neditor, not run interactively. The server keeps running until the editor client\ndisconnects.",
 		examples: ["lsp"]
 	},
 	args: { flags: {
@@ -5100,7 +5106,7 @@ const lspCommand = defineServerCommand({
 	} },
 	handler: async (args, io) => {
 		const exitCode = await withoutClientProcessIdInArgv(async () => {
-			const { startServer } = await import("./exports-8ZUN43ve.mjs");
+			const { startServer } = await import("./exports-CYa2di3d.mjs");
 			return startServer({
 				stdin: io.stdin,
 				stdout: io.stdout,
@@ -7337,12 +7343,12 @@ function mapMigrateFailure(failure) {
 	if (failure.code === "MIGRATION_PATH_NOT_FOUND") return errorPathUnreachable(failure);
 	return errorRunnerFailed(failure.summary, {
 		why: failure.why ?? "Migration runner failed",
-		fix: "Fix the issue and re-run `prisma-cli migrate --to <contract>` — previously applied migrations are preserved.",
+		fix: "Fix the issue and re-run `{bin} db migrate --to <contract>` — previously applied migrations are preserved.",
 		meta: failure.meta ?? {},
 		...ifDefined("cause", failure.cause)
 	});
 }
-const STATUS_ACTION = runCommandAction("Check every space against the database", "prisma-cli migration status");
+const STATUS_ACTION = runCommandAction("Check every space against the database", "{bin} 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
@@ -7474,11 +7480,11 @@ function createMigrateCommand(createClient) {
 			summary: "Apply planned migrations to advance the database",
 			description: "Walks every contract space (app + extensions) and applies pending on-disk\nmigrations in canonical order (extensions alphabetically, then app). It\nreplays the on-disk migration graph and never invents an edge. Use --to to\ntarget a specific contract (hash, ref name, or migration directory) and\n--show for a read-only preview of the route it would take.",
 			examples: [
-				"migrate",
-				"migrate --db $DATABASE_URL",
-				"migrate --to production",
-				"migrate --show",
-				"migrate --show --from @contract --to production"
+				"db migrate",
+				"db migrate --db $DATABASE_URL",
+				"db migrate --to production",
+				"db migrate --show",
+				"db migrate --show --from @contract --to production"
 			]
 		},
 		args: { flags: {
@@ -7539,7 +7545,7 @@ function createMigrateCommand(createClient) {
 				config: ctx.config,
 				cwd: ctx.cwd,
 				db: args.flags.db,
-				commandName: "migrate",
+				commandName: "db migrate",
 				createClient
 			});
 			if (!prepared.ok) return notOk$1(prepared.failure);
@@ -7563,7 +7569,7 @@ function createMigrateCommand(createClient) {
 			const integrityFailure = refuseContractSpaceIntegrity(aggregate, {
 				declaredExtensions: toDeclaredExtensionsFromRaw(castAs(ctx.config.extensions ?? [])),
 				checkContracts: true
-			});
+			}, migrationsDir);
 			if (integrityFailure) return notOk$1(normalizeError(integrityFailure));
 			const target = resolveRequestedTarget(args.flags.to, aggregate.app.refs, aggregate.app.graph());
 			if (!target.ok) return notOk$1(target.failure);
@@ -7720,7 +7726,7 @@ function integrityViolationToCheckFailure(violation, migrationsDir) {
 			code: "MIGRATION.CHECK_DECLARED_BUT_UNMIGRATED",
 			where: spaceRelative(violation.spaceId),
 			why: `Extension "${violation.spaceId}" is declared in \`extensions\` but has no on-disk migrations directory.`,
-			nextActions: [runCommandAction("Re-emit the extension contract-space artefacts, then plan its migrations", "prisma-cli contract emit"), chooseAction("Or remove the extension from `extensions` if it is unused")]
+			nextActions: [runCommandAction("Re-emit the extension contract-space artefacts, then plan its migrations", "{bin} contract emit"), chooseAction("Or remove the extension from `extensions` if it is unused")]
 		};
 		case "headRefMissing": return {
 			space: violation.spaceId,
@@ -7762,7 +7768,7 @@ function integrityViolationToCheckFailure(violation, migrationsDir) {
 			code: "MIGRATION.CHECK_CONTRACT_UNREADABLE",
 			where: migrationFileRelative(join(migrationsDir, violation.spaceId), "contract.json"),
 			why: `Contract for space "${violation.spaceId}" is unreadable: ${violation.detail}`,
-			nextActions: [runCommandAction("Re-emit the extension contract artefacts", "prisma-cli contract emit"), chooseAction("Or fix the descriptor producing the invalid contract")]
+			nextActions: [runCommandAction("Re-emit the extension contract artefacts", "{bin} contract emit"), chooseAction("Or fix the descriptor producing the invalid contract")]
 		};
 		case "duplicateMigrationHash": return {
 			space: violation.spaceId,
@@ -7979,7 +7985,10 @@ function renderMigrationGraphDot(graph) {
 }
 /**
 * The tree is a drawing for a reader; the DOT document is a graph description
-* for another program, so it is the one thing here that belongs on stdout.
+* for another program, so it is also the stdout payload. It appears in both
+* surfaces because the engine treats the payload as a mirror of the human
+* output: on one shared screen it suppresses the stdout copy, so the human
+* block is what keeps `--dot` visible there, while split sinks receive both.
 */
 function graphPresentations(inputs) {
 	const { tree, dot, legend } = inputs;
@@ -8002,6 +8011,10 @@ function graphPresentations(inputs) {
 				kind: "drawing",
 				lines: toneDrawing(tree)
 			}],
+			...dot === void 0 ? [] : [{
+				kind: "drawing",
+				lines: dot.split("\n")
+			}],
 			...legend === void 0 ? [] : [{
 				kind: "drawing",
 				lines: toneDrawing(legend)
@@ -8486,6 +8499,15 @@ function previewBlocks$1(result) {
 		lines: statements
 	}];
 }
+function originNoticeBlocks(result) {
+	if (result.fromDefaulted !== true) return [];
+	return [{
+		kind: "summary",
+		status: "info",
+		tone: "muted",
+		text: "No db ref set — planning from an empty database. Run db init, db update, or db sign if a database already exists."
+	}];
+}
 function planBlocks(result, migrationsRelative) {
 	const outcome = outcomeFields(result, migrationsRelative);
 	if (result.noOp) return [{
@@ -8493,17 +8515,22 @@ function planBlocks(result, migrationsRelative) {
 		status: "ok",
 		text: "No changes detected"
 	}, outcome];
-	if (result.pendingPlaceholders === true) return [{
-		kind: "summary",
-		status: "warn",
-		text: result.summary
-	}, outcome];
+	if (result.pendingPlaceholders === true) return [
+		{
+			kind: "summary",
+			status: "warn",
+			text: result.summary
+		},
+		...originNoticeBlocks(result),
+		outcome
+	];
 	return [
 		{
 			kind: "summary",
 			status: "ok",
 			text: result.summary
 		},
+		...originNoticeBlocks(result),
 		...operationBlocks$1(result),
 		outcome,
 		...previewBlocks$1(result)
@@ -8526,7 +8553,7 @@ function planNextActions(result, migrationsRelative) {
 	return [{
 		kind: "edit-file",
 		label: `Review ${written.join(" and ")}`
-	}, runCommandAction("Apply the migration", "prisma-cli migrate")];
+	}, runCommandAction("Apply the migration", "{bin} db migrate")];
 }
 function planPresentations(inputs) {
 	return {
@@ -8578,7 +8605,7 @@ const migrationPlanCommand = defineOrmCommand({
 			placeholder: "slug"
 		}),
 		from: flag.string({
-			brief: "Starting contract reference (hash, prefix, ref name, migration dir name, <dir>^, or ./path)",
+			brief: "Starting contract reference (hash, prefix, ref name, migration dir name, <dir>^, @empty, or ./path)",
 			placeholder: "contract"
 		}),
 		to: flag.string({
@@ -8803,7 +8830,7 @@ const migrationShowCommand = defineOrmCommand({
 		} catch (error) {
 			return notOk$1(normalizeError(Reflect.get(Object(error), "code") === "ENOENT" ? errorFileNotFound(contractPath, {
 				why: `Contract file not found at ${contractPath}`,
-				fix: `Run \`prisma-cli contract emit\` to generate ${relative(ctx.cwd, contractPath)}`
+				fix: `Run \`{bin} contract emit\` to generate ${relative(ctx.cwd, contractPath)}`
 			}) : errorUnexpected(error instanceof Error ? error.message : String(error), { why: "Failed to read contract file" })));
 		}
 		const familyInstance = ctx.config.family.create(createControlStack(ctx.config));
@@ -8869,7 +8896,7 @@ const migrationShowCommand = defineOrmCommand({
 		})));
 	}
 });
-const EMIT_CONTRACT = runCommandAction("Regenerate the contract", "prisma-cli contract emit");
+const EMIT_CONTRACT = runCommandAction("Regenerate the contract", "{bin} contract emit");
 function contractUnreadableFinding(reason) {
 	const message = `Could not read contract: ${reason}`;
 	return {
@@ -8877,7 +8904,7 @@ function contractUnreadableFinding(reason) {
 			code: "CONTRACT.UNREADABLE",
 			severity: "warn",
 			message,
-			hints: ["Run 'prisma-cli contract emit' to generate a valid contract"]
+			hints: ["Run '{bin} contract emit' to generate a valid contract"]
 		},
 		diagnostic: {
 			code: "CONTRACT.UNREADABLE",
@@ -8895,7 +8922,7 @@ function markerNotInHistoryFinding(space) {
 			code: "MIGRATION.MARKER_NOT_IN_HISTORY",
 			severity: "warn",
 			message,
-			hints: ["Run 'prisma-cli db sign' to overwrite the marker if the database already matches the contract", "Run 'prisma-cli db update' to push the current contract to the database"]
+			hints: ["Run '{bin} db sign' to overwrite the marker if the database already matches the contract", "Run '{bin} db update' to push the current contract to the database"]
 		},
 		diagnostic: {
 			code: "MIGRATION.MARKER_NOT_IN_HISTORY",
@@ -8903,7 +8930,7 @@ function markerNotInHistoryFinding(space) {
 			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-cli db sign"), runCommandAction("Or push the current contract to the database", "prisma-cli db update")]
+			nextActions: [runCommandAction("Overwrite the marker if the database already matches the contract", "{bin} db sign"), runCommandAction("Or push the current contract to the database", "{bin} db update")]
 		}
 	};
 }
@@ -8922,7 +8949,7 @@ function missingInvariantsFinding(inputs) {
 			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-cli migrate")],
+			nextActions: [runCommandAction("Apply the migrations that provide them", "{bin} db migrate")],
 			meta: {
 				invariants: [...inputs.missing],
 				...ifDefined("ref", inputs.refName)
@@ -8958,13 +8985,13 @@ async function readDatabaseState(inputs) {
 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-cli 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-cli migration plan --name <name>\` to author one, or pass \`--to <contract>\` to pick a reachable target.`;
+	if (!args.explicitTarget) return `No migration path from ${markerPart} to the application's contract (${targetShort}). Run \`{bin} 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 \`{bin} 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-cli migrate --to ${shortDisplayHash(args.targetHash)}\``;
+	return `${args.pendingCount} pending — run \`{bin} db migrate --to ${shortDisplayHash(args.targetHash)}\``;
 }
 /**
 * One space's section: its heading, where more than one space is in scope, on
@@ -9068,7 +9095,7 @@ const migrationStatusCommand = defineOrmCommand({
 				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-cli migration status --from <contract>"
+				retryCommand: "{bin} migration status --from <contract>"
 			});
 			if (missingDb !== null) return notOk$1(normalizeError(missingDb));
 		}
@@ -9086,7 +9113,7 @@ const migrationStatusCommand = defineOrmCommand({
 			findings.push(contractUnreadableFinding(error instanceof Error ? error.message : "unknown error"));
 		}
 		if (await loadContractRawSafely(contractConfig) !== null) {
-			const corruption = refusePackageCorruptionOnAggregate(aggregate);
+			const corruption = refusePackageCorruptionOnAggregate(aggregate, migrationsDir);
 			if (corruption) return notOk$1(normalizeError(corruption));
 		}
 		const appGraph = aggregate.app.graph();
@@ -9315,7 +9342,7 @@ function createRefDeleteCommand(execute = executeRefDeleteCommand) {
 		help: {
 			summary: "Delete a ref",
 			description: "Removes migrations/app/refs/<name>.json. The contract the ref pointed at\nis untouched: a ref is a pointer, and its target survives the deletion.",
-			examples: ["ref delete staging", "ref delete staging --json"]
+			examples: ["migration ref delete staging", "migration ref delete staging --json"]
 		},
 		args: { positionals: { name: positional.string({
 			brief: "Ref name to delete",
@@ -9381,7 +9408,7 @@ function createRefListCommand(execute = executeRefListCommand) {
 		help: {
 			summary: "List every named ref",
 			description: "Reads migrations/app/refs/ and reports each ref with the contract hash it\npoints at and the invariants recorded against it. Offline — does not\nconsult the database.",
-			examples: ["ref list", "ref list --json"]
+			examples: ["migration ref list", "migration ref list --json"]
 		},
 		needs: { config: ormConfigSection },
 		handler: async (_args, ctx) => {
@@ -9424,9 +9451,9 @@ function createRefSetCommand(execute = executeRefSetCommand) {
 			summary: "Point a ref at a contract",
 			description: "Writes migrations/app/refs/<name>.json so a logical environment name\nresolves to a contract hash. The contract is given as a hash or prefix,\nanother ref name, a migration directory name, or <dir>^ for that\nmigration's source contract. Offline — the contract must already be a\nnode of the on-disk migration graph, with its snapshot present.",
 			examples: [
-				"ref set staging 4cb4256",
-				"ref set production 20260101T1000_add_user",
-				"ref set staging production --json"
+				"migration ref set staging 4cb4256",
+				"migration ref set production 20260101T1000_add_user",
+				"migration ref set staging production --json"
 			]
 		},
 		args: { positionals: {
@@ -9465,40 +9492,35 @@ const ormCommandFamily = defineCommandFamily({
 	configSection: ormConfigSection,
 	commands: {
 		"contract emit": contractEmitCommand,
+		"contract format": formatCommand,
 		"contract infer": contractInferCommand,
 		"db init": dbInitCommand,
+		"db migrate": migrateCommand,
 		"db schema": dbSchemaCommand,
 		"db sign": dbSignCommand,
 		"db update": dbUpdateCommand,
 		"db verify": dbVerifyCommand,
-		format: formatCommand,
-		init: initCommand,
 		lsp: lspCommand,
-		migrate: migrateCommand,
 		"migration check": migrationCheckCommand,
 		"migration graph": migrationGraphCommand,
 		"migration list": migrationListCommand,
 		"migration log": migrationLogCommand,
 		"migration new": migrationNewCommand,
 		"migration plan": migrationPlanCommand,
+		"migration ref delete": refDeleteCommand,
+		"migration ref list": refListCommand,
+		"migration ref set": refSetCommand,
 		"migration show": migrationShowCommand,
 		"migration status": migrationStatusCommand,
-		"ref delete": refDeleteCommand,
-		"ref list": refListCommand,
-		"ref set": refSetCommand
+		"orm init": initCommand
 	},
 	docsBaseUrl: DOCS_BASE_URL,
 	redirects: [
 		{
 			from: "migration apply",
-			replacement: "{bin} migrate --to <contract>",
+			replacement: "{bin} db 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",
@@ -9527,37 +9549,32 @@ const ormCommandFamily = defineCommandFamily({
 });
 /** The file the ORM's loader reads when `--config` names none. */
 const ORM_CONFIG_FILENAME = "prisma.config.ts";
-/** The pre-consolidation filename, still read as a deprecated fallback. */
-const DEPRECATED_ORM_CONFIG_FILENAME = "prisma-next.config.ts";
 /**
 * Builds the engine's `Runtime.config` from `prisma.config.ts`.
 *
 * The engine ships its own synchronous loader, but the bin owns the load: the
 * ORM's c12 loader evaluates the module asynchronously and finalizes paths
 * against the config file's own directory. It reads the same shape the engine
-* does — defineConfig from `@prisma/cli-engine` with the whole Prisma Next
-* configuration nested as the single `orm` section — and keeps reading the
-* deprecated `prisma-next.config.ts` filename and flat shape, surfacing each
-* through `warn`.
+* does — defineConfig from `@prisma/cli-engine` with the whole Prisma ORM
+* configuration nested as the single `orm` section.
 *
 * Only failures that prevent evaluation entirely are diagnostics here, and
 * they carry `section: null` so they fail exactly the commands that read
 * config. Structural verdicts belong to the section validator.
 */
 async function loadOrmConfig(options) {
+	const path = resolve(options.cwd, options.configPath ?? ORM_CONFIG_FILENAME);
 	const loaded = await loadConfig(options.configPath, { cwd: options.cwd });
 	if (!loaded.ok) return {
-		path: resolve(options.cwd, options.configPath ?? ORM_CONFIG_FILENAME),
+		path,
 		sections: {},
 		diagnostics: [{
 			section: null,
 			diagnostic: toEngineDiagnostic(loaded.failure)
 		}]
 	};
-	for (const deprecation of loaded.value.deprecations) options.warn?.(deprecation.message);
-	const filename = loaded.value.deprecations.some((deprecation) => deprecation.code === "CONFIG.DEPRECATED_FILENAME") ? DEPRECATED_ORM_CONFIG_FILENAME : ORM_CONFIG_FILENAME;
 	return {
-		path: resolve(options.cwd, options.configPath ?? filename),
+		path,
 		sections: { ["orm"]: loaded.value.config },
 		diagnostics: []
 	};
@@ -9674,7 +9691,7 @@ function createImportAllowlistPlugin(allowlist, entryPath, collected) {
 async function loadContractFromTs(entryPath, options) {
 	const allowlist = options?.allowlist ?? DEFAULT_ALLOWLIST;
 	if (!existsSync(entryPath)) throw new CliStructuredError("CLI.FILE_NOT_FOUND", `Contract file not found: ${entryPath}`, { where: { path: entryPath } });
-	const tempFile = join(tmpdir(), `prisma-next-contract-${Date.now()}-${Math.random().toString(36).slice(2)}.mjs`);
+	const tempFile = join(tmpdir(), `prisma-8-contract-${Date.now()}-${Math.random().toString(36).slice(2)}.mjs`);
 	const disallowedFromEntry = /* @__PURE__ */ new Set();
 	try {
 		const result = await build({