@prisma-next/cli 0.12.0-dev.48 → 0.12.0-dev.49

package/src/commands/migration-status.ts

@@ -55,9 +55,15 @@ import { formatStyledHeader } from '../utils/formatters/styled';
 import type { CommonCommandOptions } from '../utils/global-flags';
 import { type GlobalFlags, parseGlobalFlagsOrExit } from '../utils/global-flags';
 import { shouldShowLegend, validateLegendOptions } from '../utils/legend';
-import type { StatusDiagnostic } from '../utils/migration-types';
 import { handleResult } from '../utils/result-handler';
 import { createTerminalUI, type TerminalUI } from '../utils/terminal-ui';
+import type {
+  MigrationStatusEntry,
+  MigrationStatusResult,
+  MigrationStatusSpace,
+  StatusDiagnosticJson,
+} from './json/schemas';
+import { migrationStatusJsonResultSchema } from './json/schemas';
 import {
   listRefsByContractHash,
   migrationSpaceListEntriesFromAggregate,
@@ -69,7 +75,16 @@ import {
   statusForMigrationHash,
 } from './migration-status-overlay';
 
-interface MigrationStatusOptions extends CommonCommandOptions {
+export type { StatusRef } from '../utils/migration-types';
+export type {
+  MigrationStatusEntry,
+  MigrationStatusResult,
+  MigrationStatusSpace,
+  StatusDiagnosticJson,
+};
+export { migrationStatusJsonResultSchema };
+
+export interface MigrationStatusOptions extends CommonCommandOptions {
   readonly db?: string;
   readonly config?: string;
   readonly to?: string;
@@ -79,34 +94,20 @@ interface MigrationStatusOptions extends CommonCommandOptions {
   readonly ascii?: boolean;
 }
 
-export interface MigrationStatusMigrationEntry extends MigrationListEntry {
-  readonly status: 'applied' | 'pending' | null;
-}
-
-export interface MigrationStatusSpaceResult {
-  readonly spaceId: string;
-  readonly markerHash: string | null;
-  readonly targetHash: string;
-  readonly migrations: readonly MigrationStatusMigrationEntry[];
+export interface MigrationStatusTreeSection {
+  readonly space: string;
+  readonly tree: string;
+  readonly showHeading: boolean;
 }
 
-export interface MigrationStatusResult {
+interface MigrationStatusCommandResult {
   readonly ok: true;
-  readonly spaces: readonly MigrationStatusSpaceResult[];
+  readonly spaces: readonly MigrationStatusSpace[];
   readonly summary: string;
-  readonly missingInvariantsLine?: string;
-  readonly diagnostics: readonly StatusDiagnostic[];
+  readonly diagnostics: readonly StatusDiagnosticJson[];
   readonly treeSections: readonly MigrationStatusTreeSection[];
 }
 
-export interface MigrationStatusTreeSection {
-  readonly spaceId: string;
-  readonly tree: string;
-  readonly showHeading: boolean;
-}
-
-export type { StatusDiagnostic, StatusRef } from '../utils/migration-types';
-
 function shortDisplayHash(hash: string): string {
   const stripped = hash.startsWith('sha256:') ? hash.slice(7) : hash;
   return stripped.slice(0, 12);
@@ -119,10 +120,10 @@ function resolveTarget(contractHash: string, activeRefHash: string | undefined):
 function buildStatusMigrations(
   listMigrations: readonly MigrationListEntry[],
   annotations: ReadonlyMap<string, MigrationEdgeAnnotation>,
-): readonly MigrationStatusMigrationEntry[] {
+): readonly MigrationStatusEntry[] {
   return listMigrations.map((migration) => ({
     ...migration,
-    status: statusForMigrationHash(migration.migrationHash, annotations),
+    status: statusForMigrationHash(migration.hash, annotations),
   }));
 }
 
@@ -160,7 +161,7 @@ function renderSpaceTree(args: {
   });
 }
 
-function countPending(migrations: readonly MigrationStatusMigrationEntry[]): number {
+function countPending(migrations: readonly MigrationStatusEntry[]): number {
   return migrations.filter((m) => m.status === 'pending').length;
 }
 
@@ -200,7 +201,10 @@ export function buildStatusHeadline(args: {
   return `${args.pendingCount} pending — run \`prisma-next migrate --to ${shortDisplayHash(args.targetHash)}\``;
 }
 
-export function formatStatusSummary(result: MigrationStatusResult, colorize: boolean): string {
+export function formatStatusSummary(
+  result: MigrationStatusCommandResult,
+  colorize: boolean,
+): string {
   const c = (fn: (s: string) => string, s: string) => (colorize ? fn(s) : s);
   const lines: string[] = [];
   const pendingTotal = result.spaces.reduce(
@@ -215,17 +219,23 @@ export function formatStatusSummary(result: MigrationStatusResult, colorize: boo
   } else {
     lines.push(result.summary);
   }
-  if (result.missingInvariantsLine !== undefined) {
-    lines.push(c(dim, result.missingInvariantsLine));
+  const missingInvariantsDiagnostic = result.diagnostics.find(
+    (d) => d.code === 'MIGRATION.MISSING_INVARIANTS',
+  );
+  if (missingInvariantsDiagnostic !== undefined) {
+    lines.push(c(dim, missingInvariantsDiagnostic.message));
   }
   return lines.join('\n');
 }
 
-export function formatStatusHumanOutput(result: MigrationStatusResult, colorize: boolean): string {
+export function formatStatusHumanOutput(
+  result: MigrationStatusCommandResult,
+  colorize: boolean,
+): string {
   const sections: string[] = [];
   for (const section of result.treeSections) {
     if (section.showHeading) {
-      sections.push(`${section.spaceId}:`);
+      sections.push(`${section.space}:`);
     }
     if (section.tree.length > 0) {
       sections.push(section.tree);
@@ -257,11 +267,11 @@ async function readMarkersAndLedgers(args: {
   return { markersBySpace, ledgersBySpace };
 }
 
-async function executeMigrationStatusCommand(
+export async function executeMigrationStatusCommand(
   options: MigrationStatusOptions,
   flags: GlobalFlags,
   ui: TerminalUI,
-): Promise<Result<MigrationStatusResult, CliStructuredError>> {
+): Promise<Result<MigrationStatusCommandResult, CliStructuredError>> {
   const config = await loadConfig(options.config);
   const { configPath, migrationsDir, migrationsRelative, refsDir } = resolveMigrationPaths(
     options.config,
@@ -294,7 +304,7 @@ async function executeMigrationStatusCommand(
     throw error;
   }
 
-  const diagnostics: StatusDiagnostic[] = [];
+  const diagnostics: StatusDiagnosticJson[] = [];
   let contractHash: string = EMPTY_CONTRACT_HASH;
   try {
     const envelope = await readContractEnvelope(config);
@@ -414,7 +424,7 @@ async function executeMigrationStatusCommand(
       connected = true;
       const read = await readMarkersAndLedgers({
         client,
-        spaceIds: scopedSpaces.map((s) => s.spaceId),
+        spaceIds: scopedSpaces.map((s) => s.space),
       });
       markersBySpace = new Map(read.markersBySpace);
       ledgersBySpace = new Map(read.ledgersBySpace);
@@ -456,7 +466,7 @@ async function executeMigrationStatusCommand(
   const glyphMode = ui.resolveGlyphMode(options.ascii === true);
   const colorize = flags.color !== false;
 
-  const statusSpaces: MigrationStatusSpaceResult[] = [];
+  const statusSpaces: MigrationStatusSpace[] = [];
   const treeSections: MigrationStatusTreeSection[] = [];
   let markerDiverged = false;
   let markerCannotReachTarget = false;
@@ -467,7 +477,7 @@ async function executeMigrationStatusCommand(
     ? scopedSpaces
         .filter((spaceEntry) => spaceEntry.migrations.length > 0)
         .map((spaceEntry) => ({
-          graph: aggregate.space(spaceEntry.spaceId)!.graph(),
+          graph: aggregate.space(spaceEntry.space)!.graph(),
           liveContractHash: contractHash,
         }))
     : [];
@@ -479,18 +489,18 @@ async function executeMigrationStatusCommand(
     globalLayoutInputs.length > 0 ? computeGlobalMaxDirNameWidth(globalLayoutInputs) : undefined;
 
   for (const spaceEntry of scopedSpaces) {
-    const member = aggregate.space(spaceEntry.spaceId);
+    const member = aggregate.space(spaceEntry.space);
     if (member === undefined) {
       continue;
     }
     const graph = member.graph();
     const spaceContractHash = member.contract().storage.storageHash;
     const targetHash = resolveTarget(spaceContractHash, activeRefHash);
-    if (spaceEntry.spaceId === aggregate.app.spaceId) {
+    if (spaceEntry.space === aggregate.app.spaceId) {
       headlineTargetHash = targetHash;
     }
 
-    const markerRecord = markersBySpace.get(spaceEntry.spaceId);
+    const markerRecord = markersBySpace.get(spaceEntry.space);
     const markerHash = usingFromOverride
       ? fromOverrideHash
       : (markerRecord?.storageHash ?? undefined);
@@ -521,7 +531,7 @@ async function executeMigrationStatusCommand(
       });
     }
 
-    const ledger = ledgersBySpace.get(spaceEntry.spaceId) ?? [];
+    const ledger = ledgersBySpace.get(spaceEntry.space) ?? [];
     const appliedHashes = showAppliedOverlay ? appliedHashesFromLedger(ledger) : new Set<string>();
 
     const annotations = deriveStatusEdgeAnnotations({
@@ -548,27 +558,31 @@ async function executeMigrationStatusCommand(
     totalPending += pending;
 
     statusSpaces.push({
-      spaceId: spaceEntry.spaceId,
-      markerHash: markerHash ?? null,
-      targetHash,
-      migrations,
+      space: spaceEntry.space,
+      currentContract: markerHash ?? null,
+      targetContract: targetHash,
+      migrations: [...migrations],
     });
     const displayTree =
       showSpaceHeadings && tree.length > 0 ? indentMigrationGraphTreeBlock(tree, '  ') : tree;
     treeSections.push({
-      spaceId: spaceEntry.spaceId,
+      space: spaceEntry.space,
       tree: displayTree,
       showHeading: showSpaceHeadings,
     });
   }
 
-  let missingInvariantsLine: string | undefined;
   if (connected && requiredInvariants.length > 0) {
     const markerInvariants = markersBySpace.get(aggregate.app.spaceId)?.invariants ?? [];
     const markerSet = new Set(markerInvariants);
     const missing = requiredInvariants.filter((id) => !markerSet.has(id));
     if (missing.length > 0) {
-      missingInvariantsLine = `missing invariant(s): ${missing.join(', ')}`;
+      diagnostics.push({
+        code: 'MIGRATION.MISSING_INVARIANTS',
+        ...ifDefined('ref', activeRefName),
+        invariants: missing,
+        message: `missing invariant(s): ${missing.join(', ')}`,
+      });
       if (activeRefHash !== undefined) {
         const originHash =
           markersBySpace.get(aggregate.app.spaceId)?.storageHash ?? EMPTY_CONTRACT_HASH;
@@ -614,7 +628,6 @@ async function executeMigrationStatusCommand(
       summary: 'No migrations found',
       diagnostics,
       treeSections,
-      ...ifDefined('missingInvariantsLine', missingInvariantsLine),
     });
   }
 
@@ -624,7 +637,6 @@ async function executeMigrationStatusCommand(
     summary,
     diagnostics,
     treeSections,
-    ...ifDefined('missingInvariantsLine', missingInvariantsLine),
   });
 }
 
@@ -680,23 +692,13 @@ export function createMigrationStatusCommand(): Command {
 
       const exitCode = handleResult(result, flags, ui, (statusResult) => {
         if (flags.json) {
-          ui.output(
-            JSON.stringify(
-              {
-                ok: true,
-                spaces: statusResult.spaces,
-                summary: statusResult.summary,
-                ...(statusResult.diagnostics.length > 0
-                  ? { diagnostics: statusResult.diagnostics }
-                  : {}),
-                ...(statusResult.missingInvariantsLine
-                  ? { missingInvariants: statusResult.missingInvariantsLine }
-                  : {}),
-              },
-              null,
-              2,
-            ),
-          );
+          const jsonResult: MigrationStatusResult = {
+            ok: true,
+            spaces: [...statusResult.spaces],
+            summary: statusResult.summary,
+            diagnostics: [...statusResult.diagnostics],
+          };
+          ui.output(JSON.stringify(jsonResult, null, 2));
         } else if (!flags.quiet) {
           ui.output(formatStatusHumanOutput(statusResult, flags.color !== false));
         }

package/src/utils/formatters/migration-list-graph-topology.ts

@@ -319,10 +319,10 @@ export function classifyMigrationListGraphTopology(
   entries: readonly MigrationListEntry[],
 ): MigrationListGraphTopology {
   const normalized: NormalizedEdge[] = entries.map((entry) => ({
-    hash: entry.migrationHash,
-    from: canonicalFrom(entry.from),
-    to: entry.to,
-    dirName: entry.dirName,
+    hash: entry.hash,
+    from: canonicalFrom(entry.fromContract),
+    to: entry.toContract,
+    dirName: entry.name,
   }));
   return classifyNormalizedEdges(normalized);
 }

package/src/utils/formatters/migration-list-render.ts

@@ -72,24 +72,24 @@ export function migrationGraphFromListEntries(
   const migrationByHash = new Map<string, MigrationEdge>();
 
   for (const entry of entries) {
-    const from = canonicalFrom(entry.from);
+    const from = canonicalFrom(entry.fromContract);
     const edge: MigrationEdge = {
       from,
-      to: entry.to,
-      migrationHash: entry.migrationHash,
-      dirName: entry.dirName,
+      to: entry.toContract,
+      migrationHash: entry.hash,
+      dirName: entry.name,
       createdAt: entry.createdAt,
       invariants: entry.providedInvariants,
     };
     nodes.add(from);
-    nodes.add(entry.to);
+    nodes.add(entry.toContract);
     const forward = forwardChain.get(from);
     if (forward) forward.push(edge);
     else forwardChain.set(from, [edge]);
-    const reverse = reverseChain.get(entry.to);
+    const reverse = reverseChain.get(entry.toContract);
     if (reverse) reverse.push(edge);
-    else reverseChain.set(entry.to, [edge]);
-    migrationByHash.set(entry.migrationHash, edge);
+    else reverseChain.set(entry.toContract, [edge]);
+    migrationByHash.set(entry.hash, edge);
   }
 
   return { nodes, forwardChain, reverseChain, migrationByHash };
@@ -100,7 +100,7 @@ export function buildEdgeAnnotationsByHashFromListEntries(
 ): ReadonlyMap<string, MigrationEdgeAnnotation> {
   const annotations = new Map<string, MigrationEdgeAnnotation>();
   for (const entry of entries) {
-    annotations.set(entry.migrationHash, {
+    annotations.set(entry.hash, {
       operationCount: entry.operationCount,
       invariants: entry.providedInvariants,
     });
@@ -114,7 +114,7 @@ export function buildRefsByHashFromListEntries(
   const refsByHash = new Map<string, readonly string[]>();
   for (const entry of entries) {
     if (entry.refs.length > 0) {
-      refsByHash.set(entry.to, entry.refs);
+      refsByHash.set(entry.toContract, entry.refs);
     }
   }
   return refsByHash;
@@ -193,7 +193,7 @@ export function renderMigrationListWithStyle(
     ? result.spaces
         .filter((space) => space.migrations.length > 0)
         .map((space) => ({
-          graph: graphForSpace(space.spaceId) ?? migrationGraphFromListEntries(space.migrations),
+          graph: graphForSpace(space.space) ?? migrationGraphFromListEntries(space.migrations),
           liveContractHash,
         }))
     : [];
@@ -212,7 +212,7 @@ export function renderMigrationListWithStyle(
     }
     lines.push(
       ...renderSpaceTreeBlock(
-        space.spaceId,
+        space.space,
         space.migrations,
         multiSpace,
         glyphMode,

package/src/utils/formatters/migration-list-types.ts

@@ -1,21 +1,5 @@
-export interface MigrationListEntry {
-  readonly dirName: string;
-  readonly from: string | null;
-  readonly to: string;
-  readonly migrationHash: string;
-  readonly operationCount: number;
-  readonly createdAt: string;
-  readonly refs: readonly string[];
-  readonly providedInvariants: readonly string[];
-}
-
-export interface MigrationSpaceListEntry {
-  readonly spaceId: string;
-  readonly migrations: readonly MigrationListEntry[];
-}
-
-export interface MigrationListResult {
-  readonly ok: true;
-  readonly spaces: readonly MigrationSpaceListEntry[];
-  readonly summary: string;
-}
+export type {
+  MigrationEntry as MigrationListEntry,
+  MigrationListResult,
+  MigrationSpaceListEntry,
+} from '../../commands/json/schemas';

package/src/utils/formatters/migration-log-table.ts

@@ -18,10 +18,10 @@ export interface RenderMigrationLogTableOptions {
 
 export interface SerializedLedgerEntryRecord {
   readonly space: string;
-  readonly migrationName: string;
-  readonly migrationHash: string;
-  readonly from: string | null;
-  readonly to: string;
+  readonly name: string;
+  readonly hash: string;
+  readonly fromContract: string | null;
+  readonly toContract: string;
   readonly appliedAt: string;
   readonly operationCount: number;
 }
@@ -191,9 +191,14 @@ export function renderMigrationLogTable(
 export function serializeLedgerEntriesForJson(
   entries: readonly LedgerEntryRecord[],
 ): SerializedLedgerEntryRecord[] {
-  return sortLedgerEntries(entries).map(({ appliedAt, ...rest }) => ({
-    ...rest,
-    appliedAt: formatLedgerAppliedAt(appliedAt, 'iso'),
+  return sortLedgerEntries(entries).map((entry) => ({
+    space: entry.space,
+    name: entry.migrationName,
+    hash: entry.migrationHash,
+    fromContract: entry.from,
+    toContract: entry.to,
+    appliedAt: formatLedgerAppliedAt(entry.appliedAt, 'iso'),
+    operationCount: entry.operationCount,
   }));
 }
 

package/src/utils/formatters/migrations.ts

@@ -335,11 +335,10 @@ export function formatMigrationApplyCommandOutput(
 }
 
 interface MigrationShowPresent {
-  readonly dirName: string;
-  readonly dirPath: string;
-  readonly from: string | null;
-  readonly to: string;
-  readonly migrationHash: string;
+  readonly name: string;
+  readonly fromContract: string | null;
+  readonly toContract: string;
+  readonly hash: string;
   readonly createdAt: string;
   readonly operations: readonly {
     readonly id: string;
@@ -347,7 +346,6 @@ interface MigrationShowPresent {
     readonly operationClass: string;
   }[];
   readonly preview: OperationPreview;
-  readonly summary: string;
 }
 
 interface MigrationShowResult {
@@ -360,10 +358,10 @@ function formatSpaceShowBlock(space: MigrationShowPresent, useColor: boolean): r
   const formatDimText = (text: string) => formatDim(useColor, text);
 
   const lines: string[] = [];
-  lines.push(`${formatGreen('✔')} ${space.dirName}`);
-  lines.push(`${formatDimText(`  from: ${space.from ?? '(baseline)'}`)}`);
-  lines.push(`${formatDimText(`  to:   ${space.to}`)}`);
-  lines.push(`${formatDimText(`  migrationHash: ${space.migrationHash}`)}`);
+  lines.push(`${formatGreen('✔')} ${space.name}`);
+  lines.push(`${formatDimText(`  from: ${space.fromContract ?? '(baseline)'}`)}`);
+  lines.push(`${formatDimText(`  to:   ${space.toContract}`)}`);
+  lines.push(`${formatDimText(`  hash: ${space.hash}`)}`);
   lines.push(`${formatDimText(`  created: ${space.createdAt}`)}`);
 
   lines.push('');

package/src/utils/integrity-violation-to-check-failure.ts

@@ -1,12 +1,8 @@
 import type { IntegrityViolation } from '@prisma-next/migration-tools/aggregate';
 import { join, relative } from 'pathe';
+import type { CheckFailure } from '../commands/json/schemas';
 
-export interface CheckFailure {
-  readonly pnCode: string;
-  readonly where: string;
-  readonly why: string;
-  readonly fix: string;
-}
+export type { CheckFailure } from '../commands/json/schemas';
 
 function migrationPathRelative(dirPath: string): string {
   return relative(process.cwd(), dirPath);
@@ -34,7 +30,8 @@ export function integrityViolationToCheckFailure(
   switch (violation.kind) {
     case 'hashMismatch':
       return {
-        pnCode: 'PN-MIG-CHECK-001',
+        space: violation.spaceId,
+        code: 'PN-MIG-CHECK-001',
         where: migrationFileRelative(
           join(migrationsDir, violation.spaceId, violation.dirName),
           'migration.json',
@@ -44,84 +41,96 @@ export function integrityViolationToCheckFailure(
       };
     case 'providedInvariantsMismatch':
       return {
-        pnCode: 'PN-MIG-CHECK-002',
+        space: violation.spaceId,
+        code: 'PN-MIG-CHECK-002',
         where: packageRelative(violation.spaceId, violation.dirName),
         why: `Migration "${violation.dirName}" providedInvariants in migration.json disagrees with ops.json.`,
         fix: 'Re-emit the migration package so migration.json and ops.json agree.',
       };
     case 'packageUnloadable':
       return {
-        pnCode: 'PN-MIG-CHECK-002',
+        space: violation.spaceId,
+        code: 'PN-MIG-CHECK-002',
         where: packageRelative(violation.spaceId, violation.dirName),
         why: `Migration "${violation.dirName}" could not be loaded: ${violation.detail}`,
         fix: 'Re-emit the migration package or restore from version control.',
       };
     case 'sameSourceAndTarget':
       return {
-        pnCode: 'PN-MIG-CHECK-007',
+        space: violation.spaceId,
+        code: 'PN-MIG-CHECK-007',
         where: packageRelative(violation.spaceId, violation.dirName),
         why: `Migration "${violation.dirName}" in space "${violation.spaceId}" has source equal to target (${violation.hash}) with no data invariant — a true no-op self-edge.`,
         fix: 'Add a data operation if this self-edge was meant to carry a data invariant, or delete the migration if it is a true no-op.',
       };
     case 'orphanSpaceDir':
       return {
-        pnCode: 'PN-MIG-CHECK-008',
+        space: violation.spaceId,
+        code: 'PN-MIG-CHECK-008',
         where: spaceRelative(violation.spaceId),
         why: `Contract-space directory "${violation.spaceId}" exists on disk but no extension declares it.`,
         fix: 'Remove the orphan directory, or declare the extension in `extensionPacks`.',
       };
     case 'declaredButUnmigrated':
       return {
-        pnCode: 'PN-MIG-CHECK-009',
+        space: violation.spaceId,
+        code: 'PN-MIG-CHECK-009',
         where: spaceRelative(violation.spaceId),
         why: `Extension "${violation.spaceId}" is declared in \`extensionPacks\` but has no on-disk migrations directory.`,
         fix: 'Re-emit the extension contract-space artefacts with `prisma-next contract emit` and migration planning, or remove the extension from `extensionPacks` if it is unused.',
       };
     case 'headRefMissing':
       return {
-        pnCode: 'PN-MIG-CHECK-010',
+        space: violation.spaceId,
+        code: 'PN-MIG-CHECK-010',
         where: refRelative(violation.spaceId, 'head'),
         why: `Head ref \`refs/head.json\` is missing for contract space "${violation.spaceId}".`,
         fix: 'Re-emit the contract-space migrations and head ref artefacts, or restore `refs/head.json` from version control.',
       };
     case 'headRefNotInGraph':
       return {
-        pnCode: 'PN-MIG-CHECK-011',
+        space: violation.spaceId,
+        code: 'PN-MIG-CHECK-011',
         where: refRelative(violation.spaceId, 'head'),
         why: `Head ref ${violation.hash} for contract space "${violation.spaceId}" is not present in its migration graph.`,
         fix: 'Re-emit the contract space migrations, or restore the missing migration package.',
       };
     case 'refUnreadable':
       return {
-        pnCode: 'PN-MIG-CHECK-012',
+        space: violation.spaceId,
+        code: 'PN-MIG-CHECK-012',
         where: refRelative(violation.spaceId, violation.refName),
         why: `Ref "${violation.refName}" for contract space "${violation.spaceId}" is unreadable: ${violation.detail}`,
         fix: 'Repair or remove the corrupt ref file.',
       };
     case 'targetMismatch':
       return {
-        pnCode: 'PN-MIG-CHECK-013',
+        space: violation.spaceId,
+        code: 'PN-MIG-CHECK-013',
         where: spaceRelative(violation.spaceId),
         why: `Contract space "${violation.spaceId}" targets "${violation.actual}" but the project targets "${violation.expected}".`,
         fix: 'Update the extension to target the configured database, or change the project target.',
       };
     case 'disjointness':
       return {
-        pnCode: 'PN-MIG-CHECK-014',
+        space: 'app',
+        code: 'PN-MIG-CHECK-014',
         where: migrationPathRelative(migrationsDir),
         why: `Storage element "${violation.element}" is claimed by multiple contract spaces: ${violation.claimedBy.join(', ')}.`,
         fix: 'Update the contracts so each storage element is owned by exactly one contract space.',
       };
     case 'contractUnreadable':
       return {
-        pnCode: 'PN-MIG-CHECK-015',
+        space: violation.spaceId,
+        code: 'PN-MIG-CHECK-015',
         where: migrationFileRelative(join(migrationsDir, violation.spaceId), 'contract.json'),
         why: `Contract for space "${violation.spaceId}" is unreadable: ${violation.detail}`,
         fix: 'Re-emit the extension contract artefacts, or fix the descriptor producing the invalid contract.',
       };
     case 'duplicateMigrationHash':
       return {
-        pnCode: 'PN-MIG-CHECK-016',
+        space: violation.spaceId,
+        code: 'PN-MIG-CHECK-016',
         where: spaceRelative(violation.spaceId),
         why: `Multiple migrations in space "${violation.spaceId}" share migrationHash "${violation.migrationHash}" (${violation.dirNames.join(', ')}).`,
         fix: 'Re-emit one of the conflicting packages so each migrationHash is unique.',