@prisma-next/cli 0.5.0-dev.7 → 0.5.0-dev.71

package/src/commands/init/templates/code-templates.ts

@@ -108,12 +108,15 @@ export const contract = defineContract(
 }
 
 function starterSchemaPslPostgres(): string {
-  return `model User {
+  return `// use prisma-next
+
+model User {
   id        Int      @id @default(autoincrement())
   email     String   @unique
   name      String?
   posts     Post[]
   createdAt DateTime @default(now())
+  updatedAt temporal.updatedAt()
 }
 
 model Post {
@@ -123,12 +126,15 @@ model Post {
   author    User     @relation(fields: [authorId], references: [id])
   authorId  Int
   createdAt DateTime @default(now())
+  updatedAt temporal.updatedAt()
 }
 `;
 }
 
 function starterSchemaPslMongo(): string {
-  return `model User {
+  return `// use prisma-next
+
+model User {
   id    ObjectId @id @map("_id")
   email String   @unique
   name  String?
@@ -161,7 +167,8 @@ export const contract = defineContract(
           id: field.id.uuidv7(),
           email: field.text().unique(),
           name: field.text().optional(),
-          createdAt: field.createdAt(),
+          createdAt: field.temporal.createdAt(),
+          updatedAt: field.temporal.updatedAt(),
         },
         relations: {
           posts: rel.hasMany('Post', { by: 'authorId' }),
@@ -174,7 +181,8 @@ export const contract = defineContract(
           title: field.text(),
           content: field.text().optional(),
           authorId: field.uuid(),
-          createdAt: field.createdAt(),
+          createdAt: field.temporal.createdAt(),
+          updatedAt: field.temporal.updatedAt(),
         },
         relations: {
           author: rel.belongsTo('User', { from: 'authorId', to: 'id' }),

package/src/commands/inspect-live-schema.ts

@@ -1,5 +1,5 @@
 import type { CoreSchemaView } from '@prisma-next/framework-components/control';
-import { validatePrintableSqlSchemaIR } from '@prisma-next/psl-printer';
+import type { PslDocumentAst } from '@prisma-next/framework-components/psl-ast';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { relative, resolve } from 'pathe';
 import { loadConfig } from '../config-loader';
@@ -33,6 +33,12 @@ export interface InspectLiveSchemaResult {
   readonly config: LoadedCliConfig;
   readonly schema: unknown;
   readonly schemaView: CoreSchemaView | undefined;
+  /**
+   * PSL AST inferred from the introspected schema, when the configured family
+   * implements `PslContractInferCapable`. `undefined` for families that do not
+   * support inference (e.g. Mongo today).
+   */
+  readonly pslContractAst: PslDocumentAst | undefined;
   readonly target: {
     readonly familyId: string;
     readonly id: string;
@@ -122,14 +128,12 @@ export async function inspectLiveSchema(
   const onProgress = createProgressAdapter({ ui, flags });
 
   try {
-    const schemaIR = await client.introspect({
+    const schema = await client.introspect({
       connection: dbConnection,
       onProgress,
     });
-    // TODO(TML-2251): Remove SQL-specific branching — SQL should use the same family-agnostic path as Mongo.
-    const schema =
-      config.family.familyId === 'sql' ? validatePrintableSqlSchemaIR(schemaIR) : schemaIR;
     const schemaView = client.toSchemaView(schema);
+    const pslContractAst = client.inferPslContract(schema);
 
     const dbUrl = typeof dbConnection === 'string' ? maskConnectionUrl(dbConnection) : undefined;
 
@@ -137,6 +141,7 @@ export async function inspectLiveSchema(
       config,
       schema,
       schemaView,
+      pslContractAst,
       target: {
         familyId: config.family.familyId,
         id: config.target.targetId,

package/src/commands/migration-apply.ts

@@ -1,9 +1,14 @@
-import { verifyMigrationBundle } from '@prisma-next/migration-tools/attestation';
 import { EMPTY_CONTRACT_HASH } from '@prisma-next/migration-tools/constants';
-import { findPathWithDecision } from '@prisma-next/migration-tools/dag';
+import {
+  errorNoInvariantPath,
+  errorUnknownInvariant,
+  MigrationToolsError,
+} from '@prisma-next/migration-tools/errors';
+import { findPathWithDecision } from '@prisma-next/migration-tools/migration-graph';
+import type { OnDiskMigrationPackage } from '@prisma-next/migration-tools/package';
+import type { RefEntry } from '@prisma-next/migration-tools/refs';
 import { readRefs, resolveRef } from '@prisma-next/migration-tools/refs';
-import type { MigrationBundle } from '@prisma-next/migration-tools/types';
-import { MigrationToolsError } from '@prisma-next/migration-tools/types';
+import { ifDefined } from '@prisma-next/utils/defined';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { Command } from 'commander';
 
@@ -18,11 +23,12 @@ import {
   errorRuntime,
   errorTargetMigrationNotSupported,
   errorUnexpected,
+  mapMigrationToolsError,
 } from '../utils/cli-errors';
 import {
   addGlobalOptions,
-  loadAllBundles,
-  type MigrationBundleSet,
+  collectDeclaredInvariants,
+  loadMigrationPackages,
   maskConnectionUrl,
   readContractEnvelope,
   resolveMigrationPaths,
@@ -30,6 +36,7 @@ import {
   setCommandExamples,
   targetSupportsMigrations,
   toPathDecisionResult,
+  toStructuralEdge,
 } from '../utils/command-helpers';
 import { formatMigrationApplyCommandOutput } from '../utils/formatters/migrations';
 import { formatStyledHeader } from '../utils/formatters/styled';
@@ -51,7 +58,7 @@ export interface MigrationApplyResult {
   readonly markerHash: string;
   readonly applied: readonly {
     readonly dirName: string;
-    readonly from: string;
+    readonly from: string | null;
     readonly to: string;
     readonly operationsExecuted: number;
   }[];
@@ -62,11 +69,14 @@ export interface MigrationApplyResult {
     readonly alternativeCount: number;
     readonly tieBreakReasons: readonly string[];
     readonly refName?: string;
+    readonly requiredInvariants: readonly string[];
+    readonly satisfiedInvariants: readonly string[];
     readonly selectedPath: readonly {
       readonly dirName: string;
-      readonly migrationId: string;
+      readonly migrationHash: string;
       readonly from: string;
       readonly to: string;
+      readonly invariants: readonly string[];
     }[];
   };
   readonly timings: {
@@ -74,19 +84,6 @@ export interface MigrationApplyResult {
   };
 }
 
-function mapMigrationToolsError(error: unknown): CliStructuredErrorType {
-  if (MigrationToolsError.is(error)) {
-    return errorRuntime(error.message, {
-      why: error.why,
-      fix: error.fix,
-      meta: { code: error.code, ...(error.details ?? {}) },
-    });
-  }
-  return errorUnexpected(error instanceof Error ? error.message : String(error), {
-    why: `Unexpected error during migration apply: ${error instanceof Error ? error.message : String(error)}`,
-  });
-}
-
 function mapApplyFailure(failure: MigrationApplyFailure): CliStructuredErrorType {
   return errorRuntime(failure.summary, {
     why: failure.why ?? 'Migration runner failed',
@@ -95,13 +92,14 @@ function mapApplyFailure(failure: MigrationApplyFailure): CliStructuredErrorType
   });
 }
 
-function packageToStep(pkg: MigrationBundle): MigrationApplyStep {
+function packageToStep(pkg: OnDiskMigrationPackage): MigrationApplyStep {
   return {
     dirName: pkg.dirName,
-    from: pkg.manifest.from,
-    to: pkg.manifest.to,
-    toContract: pkg.manifest.toContract,
+    from: pkg.metadata.from,
+    to: pkg.metadata.to,
+    toContract: pkg.metadata.toContract,
     operations: pkg.ops,
+    providedInvariants: pkg.metadata.providedInvariants,
   };
 }
 
@@ -112,7 +110,7 @@ async function executeMigrationApplyCommand(
   startTime: number,
 ): Promise<Result<MigrationApplyResult, CliStructuredErrorType>> {
   const config = await loadConfig(options.config);
-  const { configPath, migrationsDir, migrationsRelative, refsDir } = resolveMigrationPaths(
+  const { configPath, appMigrationsDir, appMigrationsRelative, refsDir } = resolveMigrationPaths(
     options.config,
     config,
   );
@@ -143,14 +141,14 @@ async function executeMigrationApplyCommand(
     );
   }
 
-  let destinationHash: string;
-  let refName: string | undefined;
+  let refEntry: RefEntry | undefined;
+  let envelopeHash: string | undefined;
+  const refName = options.ref;
 
-  if (options.ref) {
-    refName = options.ref;
+  if (refName) {
     try {
       const refs = await readRefs(refsDir);
-      destinationHash = resolveRef(refs, refName).hash;
+      refEntry = resolveRef(refs, refName);
     } catch (error) {
       if (MigrationToolsError.is(error)) {
         return notOk(mapMigrationToolsError(error));
@@ -160,7 +158,7 @@ async function executeMigrationApplyCommand(
   } else {
     try {
       const envelope = await readContractEnvelope(config);
-      destinationHash = envelope.storageHash;
+      envelopeHash = envelope.storageHash;
     } catch (error) {
       return notOk(
         errorRuntime('Current contract is unavailable', {
@@ -170,11 +168,12 @@ async function executeMigrationApplyCommand(
       );
     }
   }
+  const destinationHash = refEntry?.hash ?? envelopeHash!;
 
   if (!flags.json && !flags.quiet) {
     const details: Array<{ label: string; value: string }> = [
       { label: 'config', value: configPath },
-      { label: 'migrations', value: migrationsRelative },
+      { label: 'migrations', value: appMigrationsRelative },
     ];
     if (typeof dbConnection === 'string') {
       details.push({
@@ -196,9 +195,9 @@ async function executeMigrationApplyCommand(
   }
 
   // Read migrations and build migration chain model (offline — no DB needed)
-  let migrations: MigrationBundleSet;
+  let migrations: Awaited<ReturnType<typeof loadMigrationPackages>>;
   try {
-    migrations = await loadAllBundles(migrationsDir);
+    migrations = await loadMigrationPackages(appMigrationsDir);
   } catch (error) {
     if (MigrationToolsError.is(error)) {
       return notOk(mapMigrationToolsError(error));
@@ -206,27 +205,6 @@ async function executeMigrationApplyCommand(
     throw error;
   }
 
-  // Defense in depth: re-hash every bundle and confirm the recorded
-  // `migrationId` matches the on-disk `(manifest, ops)`. Catches FS
-  // corruption, partial writes, and post-emit hand edits before we
-  // start touching the database.
-  for (const bundle of migrations.bundles) {
-    const verified = verifyMigrationBundle(bundle);
-    if (!verified.ok) {
-      return notOk(
-        errorRuntime(`Migration package is corrupt: ${bundle.dirName}`, {
-          why: `Stored migrationId "${verified.storedMigrationId}" does not match the recomputed hash "${verified.computedMigrationId}" for ${migrationsRelative}/${bundle.dirName}. The migration.json or ops.json has been edited or partially written since emit.`,
-          fix: `Re-emit the package by running \`node "${migrationsRelative}/${bundle.dirName}/migration.ts"\`, or restore the directory from version control.`,
-          meta: {
-            dirName: bundle.dirName,
-            storedMigrationId: verified.storedMigrationId,
-            computedMigrationId: verified.computedMigrationId,
-          },
-        }),
-      );
-    }
-  }
-
   const client = createControlClient({
     family: config.family,
     target: config.target,
@@ -239,14 +217,40 @@ async function executeMigrationApplyCommand(
     await client.connect(dbConnection);
     const marker = await client.readMarker();
 
+    // Pre-check unknown invariants against `(declared by graph) ∪
+    // (already on the marker)`. The union catches the edge case where the
+    // ref carries an invariant whose declaring migration was retired (e.g.
+    // history rewritten) but whose id is recorded on the marker —
+    // surfacing that as MIGRATION.UNKNOWN_INVARIANT would be misleading
+    // because the database has already satisfied the requirement, so the
+    // marker-subtraction below empties `effectiveRequired` and apply
+    // short-circuits to "Already up to date".
+    if (refEntry && refEntry.invariants.length > 0) {
+      const declared = collectDeclaredInvariants(migrations.graph);
+      const known = new Set<string>(declared);
+      for (const id of marker?.invariants ?? []) known.add(id);
+      const unknown = refEntry.invariants.filter((id) => !known.has(id));
+      if (unknown.length > 0) {
+        return notOk(
+          mapMigrationToolsError(
+            errorUnknownInvariant({
+              ...ifDefined('refName', refName),
+              unknown,
+              declared: [...declared].sort(),
+            }),
+          ),
+        );
+      }
+    }
+
     // --- No migrations on disk ---
     if (migrations.bundles.length === 0) {
       if (marker?.storageHash) {
         return notOk(
           errorRuntime('Database has state but no migrations exist', {
-            why: `The database marker hash "${marker.storageHash}" exists but no migrations were found in ${migrationsRelative}`,
+            why: `The database marker hash "${marker.storageHash}" exists but no migrations were found in ${appMigrationsRelative}`,
             fix: 'Ensure the migrations directory is correct. If the database was managed with `db init` or `db update`, run `prisma-next db sign` to update the marker.',
-            meta: { markerHash: marker.storageHash, migrationsDir: migrationsRelative },
+            meta: { markerHash: marker.storageHash, migrationsDir: appMigrationsRelative },
           }),
         );
       }
@@ -254,9 +258,9 @@ async function executeMigrationApplyCommand(
       if (destinationHash !== EMPTY_CONTRACT_HASH) {
         return notOk(
           errorRuntime('Current contract has no planned migrations', {
-            why: `No migrations were found in ${migrationsRelative}, but current contract hash is "${destinationHash}"`,
+            why: `No migrations were found in ${appMigrationsRelative}, but current contract hash is "${destinationHash}"`,
             fix: 'Run `prisma-next migration plan` to create a migration for the current contract.',
-            meta: { destinationHash, migrationsDir: migrationsRelative },
+            meta: { destinationHash, migrationsDir: appMigrationsRelative },
           }),
         );
       }
@@ -291,7 +295,7 @@ async function executeMigrationApplyCommand(
     if (markerHash !== undefined && !migrations.graph.nodes.has(markerHash)) {
       return notOk(
         errorRuntime('Database marker does not match any known migration', {
-          why: `The database marker hash "${markerHash}" is not found in the migration history at ${migrationsRelative}`,
+          why: `The database marker hash "${markerHash}" is not found in the migration history at ${appMigrationsRelative}`,
           fix: 'Ensure the migrations directory matches this database. If the database was managed with `db init` or `db update`, run `prisma-next db sign` to update the marker.',
           meta: { markerHash, knownNodes: [...migrations.graph.nodes] },
         }),
@@ -301,20 +305,38 @@ async function executeMigrationApplyCommand(
     if (!migrations.graph.nodes.has(destinationHash)) {
       return notOk(
         errorRuntime('Current contract has no planned migration path', {
-          why: `Current contract hash "${destinationHash}" is not present in the migration history at ${migrationsRelative}`,
+          why: `Current contract hash "${destinationHash}" is not present in the migration history at ${appMigrationsRelative}`,
           fix: 'Run `prisma-next migration plan` to create a migration for the current contract, then re-run apply.',
           meta: { destinationHash, knownNodes: [...migrations.graph.nodes] },
         }),
       );
     }
 
-    // --- Resolve path and apply ---
-
     // "No marker" means the database is fresh — start from the empty contract hash.
     const originHash = markerHash ?? EMPTY_CONTRACT_HASH;
 
-    const decision = findPathWithDecision(migrations.graph, originHash, destinationHash, refName);
-    if (!decision) {
+    const appliedInvariants = new Set(marker?.invariants ?? []);
+    const effectiveRequired = new Set(
+      (refEntry?.invariants ?? []).filter((id) => !appliedInvariants.has(id)),
+    );
+
+    const outcome = findPathWithDecision(migrations.graph, originHash, destinationHash, {
+      ...ifDefined('refName', refName),
+      required: effectiveRequired,
+    });
+    if (outcome.kind === 'unsatisfiable') {
+      return notOk(
+        mapMigrationToolsError(
+          errorNoInvariantPath({
+            ...ifDefined('refName', refName),
+            required: [...effectiveRequired].sort(),
+            missing: outcome.missing,
+            structuralPath: outcome.structuralPath.map(toStructuralEdge),
+          }),
+        ),
+      );
+    }
+    if (outcome.kind === 'unreachable') {
       return notOk(
         errorRuntime('No migration path from current state to target', {
           why: `Cannot find a path from "${originHash}" to target "${destinationHash}"`,
@@ -324,10 +346,9 @@ async function executeMigrationApplyCommand(
       );
     }
 
-    const pendingPath = decision.selectedPath;
-    const pathDecision = toPathDecisionResult(decision);
+    const pathDecision = toPathDecisionResult(outcome.decision);
 
-    if (pendingPath.length === 0) {
+    if (outcome.decision.selectedPath.length === 0) {
       return ok({
         ok: true,
         migrationsApplied: 0,
@@ -342,7 +363,7 @@ async function executeMigrationApplyCommand(
 
     const bundleByDir = new Map(migrations.bundles.map((b) => [b.dirName, b]));
     const pendingMigrations: MigrationApplyStep[] = [];
-    for (const migration of pendingPath) {
+    for (const migration of outcome.decision.selectedPath) {
       const pkg = bundleByDir.get(migration.dirName);
       if (!pkg) {
         return notOk(
@@ -376,7 +397,7 @@ async function executeMigrationApplyCommand(
     return ok({
       ok: true,
       migrationsApplied: value.migrationsApplied,
-      migrationsTotal: pendingPath.length,
+      migrationsTotal: outcome.decision.selectedPath.length,
       markerHash: value.markerHash,
       applied: value.applied,
       summary: value.summary,

package/src/commands/migration-new.ts

@@ -11,32 +11,36 @@
 import { readFileSync } from 'node:fs';
 import type { Contract } from '@prisma-next/contract/types';
 import { getEmittedArtifactPaths } from '@prisma-next/emitter';
-import { createControlStack } from '@prisma-next/framework-components/control';
-import { computeMigrationId } from '@prisma-next/migration-tools/attestation';
-import { EMPTY_CONTRACT_HASH } from '@prisma-next/migration-tools/constants';
-import { findLatestMigration, reconstructGraph } from '@prisma-next/migration-tools/dag';
+import { APP_SPACE_ID, createControlStack } from '@prisma-next/framework-components/control';
+import { MigrationToolsError } from '@prisma-next/migration-tools/errors';
+import { computeMigrationHash } from '@prisma-next/migration-tools/hash';
 import {
   copyFilesWithRename,
   formatMigrationDirName,
   readMigrationsDir,
   writeMigrationPackage,
 } from '@prisma-next/migration-tools/io';
+import type { MigrationMetadata } from '@prisma-next/migration-tools/metadata';
+import {
+  findLatestMigration,
+  reconstructGraph,
+} from '@prisma-next/migration-tools/migration-graph';
 import { writeMigrationTs } from '@prisma-next/migration-tools/migration-ts';
-import type { MigrationManifest } from '@prisma-next/migration-tools/types';
-import { MigrationToolsError } from '@prisma-next/migration-tools/types';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { Command } from 'commander';
-import { join, relative, resolve } from 'pathe';
+import { join, relative } from 'pathe';
 import { loadConfig } from '../config-loader';
 import {
   CliStructuredError,
   errorRuntime,
   errorTargetMigrationNotSupported,
   errorUnexpected,
+  mapMigrationToolsError,
 } from '../utils/cli-errors';
 import {
   addGlobalOptions,
   getTargetMigrations,
+  resolveContractPath,
   resolveMigrationPaths,
   setCommandDescriptions,
   setCommandExamples,
@@ -57,7 +61,7 @@ interface MigrationNewOptions extends CommonCommandOptions {
 interface MigrationNewResult {
   readonly ok: true;
   readonly dir: string;
-  readonly from: string;
+  readonly from: string | null;
   readonly to: string;
   readonly summary: string;
 }
@@ -66,13 +70,9 @@ async function executeMigrationNewCommand(
   options: MigrationNewOptions,
 ): Promise<Result<MigrationNewResult, CliStructuredError>> {
   const config = await loadConfig(options.config);
-  const { migrationsDir, migrationsRelative } = resolveMigrationPaths(options.config, config);
+  const { appMigrationsDir, appMigrationsRelative } = resolveMigrationPaths(options.config, config);
 
-  const contractPath = config.contract?.output ?? 'contract.json';
-  const contractPathAbsolute = resolve(
-    options.config ? resolve(options.config, '..') : process.cwd(),
-    contractPath,
-  );
+  const contractPathAbsolute = resolveContractPath(config);
 
   let contractJsonContent: string;
   try {
@@ -116,37 +116,37 @@ async function executeMigrationNewCommand(
   }
 
   let fromContract: Contract | null = null;
-  let fromHash: string = EMPTY_CONTRACT_HASH;
+  let fromHash: string | null = null;
   let fromContractSourceDir: string | null = null;
 
   try {
-    const packages = await readMigrationsDir(migrationsDir);
+    const packages = await readMigrationsDir(appMigrationsDir);
 
     if (packages.length > 0) {
       const graph = reconstructGraph(packages);
 
       if (options.from) {
-        const match = packages.find((p) => p.manifest.to.startsWith(options.from!));
+        const match = packages.find((p) => p.metadata.to.startsWith(options.from!));
         if (!match) {
           return notOk(
             errorRuntime('Starting contract not found', {
-              why: `No migration with to hash matching "${options.from}" exists in ${migrationsRelative}`,
+              why: `No migration with to hash matching "${options.from}" exists in ${appMigrationsRelative}`,
               fix: 'Check that the --from hash matches a known migration target hash.',
             }),
           );
         }
-        fromHash = match.manifest.to;
-        fromContract = match.manifest.toContract;
+        fromHash = match.metadata.to;
+        fromContract = match.metadata.toContract;
         fromContractSourceDir = match.dirPath;
       } else {
         const latestMigration = findLatestMigration(graph);
         if (latestMigration) {
           fromHash = latestMigration.to;
           const leafPkg = packages.find(
-            (p) => p.manifest.migrationId === latestMigration.migrationId,
+            (p) => p.metadata.migrationHash === latestMigration.migrationHash,
           );
           if (leafPkg) {
-            fromContract = leafPkg.manifest.toContract;
+            fromContract = leafPkg.metadata.toContract;
             fromContractSourceDir = leafPkg.dirPath;
           }
         }
@@ -154,22 +154,16 @@ async function executeMigrationNewCommand(
     }
   } catch (error) {
     if (MigrationToolsError.is(error)) {
-      return notOk(
-        errorRuntime(error.message, {
-          why: error.why,
-          fix: error.fix,
-          meta: { code: error.code },
-        }),
-      );
+      return notOk(mapMigrationToolsError(error));
     }
     throw error;
   }
 
-  if (fromHash === toStorageHash) {
+  if (fromHash === toStorageHash && !options.from) {
     return notOk(
       errorRuntime('No changes detected', {
         why: 'The from and to contract hashes are identical — there is nothing to migrate.',
-        fix: 'Change the contract and run `prisma-next contract emit` before creating a new migration.',
+        fix: 'Change the contract and run `prisma-next contract emit` before creating a new migration. To author a data-only migration on the current contract hash, pass `--from <hash>` explicitly.',
       }),
     );
   }
@@ -177,16 +171,15 @@ async function executeMigrationNewCommand(
   const timestamp = new Date();
   const slug = options.name ?? 'migration';
   const dirName = formatMigrationDirName(timestamp, slug);
-  const packageDir = join(migrationsDir, dirName);
+  const packageDir = join(appMigrationsDir, dirName);
 
   // `migration new` scaffolds an empty `migration.ts` for the user to
   // fill, so we attest over `ops: []`. Re-running self-emit after the
-  // user adds operations will produce a different `migrationId` (over
+  // user adds operations will produce a different `migrationHash` (over
   // the real ops). This is intentional — there is no on-disk draft.
-  const baseManifest: Omit<MigrationManifest, 'migrationId'> = {
+  const baseMetadata: Omit<MigrationMetadata, 'migrationHash'> = {
     from: fromHash,
     to: toStorageHash,
-    kind: 'regular',
     fromContract,
     toContract: toContractJson,
     hints: {
@@ -195,11 +188,12 @@ async function executeMigrationNewCommand(
       plannerVersion: '1.0.0',
     },
     labels: [],
+    providedInvariants: [],
     createdAt: timestamp.toISOString(),
   };
-  const manifest: MigrationManifest = {
-    ...baseManifest,
-    migrationId: computeMigrationId(baseManifest, []),
+  const metadata: MigrationMetadata = {
+    ...baseMetadata,
+    migrationHash: computeMigrationHash(baseMetadata, []),
   };
 
   const migrations = getTargetMigrations(config.target);
@@ -218,7 +212,7 @@ async function executeMigrationNewCommand(
       ...(config.extensionPacks ?? []),
     ]);
 
-    await writeMigrationPackage(packageDir, manifest, []);
+    await writeMigrationPackage(packageDir, metadata, []);
     const destinationArtifacts = getEmittedArtifactPaths(contractPathAbsolute);
     await copyFilesWithRename(packageDir, [
       { sourcePath: destinationArtifacts.jsonPath, destName: 'end-contract.json' },
@@ -237,12 +231,15 @@ async function executeMigrationNewCommand(
     const stack = createControlStack(config);
     const familyInstance = config.family.create(stack);
     const planner = migrations.createPlanner(familyInstance);
-    const emptyPlan = planner.emptyMigration({
-      packageDir,
-      contractJsonPath: join(packageDir, 'end-contract.json'),
-      fromHash,
-      toHash: toStorageHash,
-    });
+    const emptyPlan = planner.emptyMigration(
+      {
+        packageDir,
+        contractJsonPath: join(packageDir, 'end-contract.json'),
+        fromHash,
+        toHash: toStorageHash,
+      },
+      APP_SPACE_ID,
+    );
     await writeMigrationTs(packageDir, emptyPlan.renderTypeScript());
 
     return ok({