@prisma-next/cli 0.4.0-dev.9 → 0.4.1

package/src/commands/migration-show.ts

@@ -2,7 +2,7 @@ import type { MigrationPlanOperation } from '@prisma-next/framework-components/c
 import { findLatestMigration, reconstructGraph } from '@prisma-next/migration-tools/dag';
 import { readMigrationPackage, readMigrationsDir } from '@prisma-next/migration-tools/io';
 import type { MigrationBundle } from '@prisma-next/migration-tools/types';
-import { isAttested, MigrationToolsError } 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 { relative, resolve } from 'pathe';
@@ -31,7 +31,7 @@ export interface MigrationShowResult {
   readonly dirPath: string;
   readonly from: string;
   readonly to: string;
-  readonly migrationId: string | null;
+  readonly migrationId: string;
   readonly kind: string;
   readonly createdAt: string;
   readonly operations: readonly {
@@ -52,8 +52,7 @@ export function resolveByHashPrefix(
   prefix: string,
 ): Result<MigrationBundle, CliStructuredError> {
   const normalizedPrefix = prefix.startsWith('sha256:') ? prefix : `sha256:${prefix}`;
-  const attested = packages.filter((p) => typeof p.manifest.migrationId === 'string');
-  const matches = attested.filter((p) => p.manifest.migrationId!.startsWith(normalizedPrefix));
+  const matches = packages.filter((p) => p.manifest.migrationId.startsWith(normalizedPrefix));
 
   if (matches.length === 1) {
     return ok(matches[0]!);
@@ -62,7 +61,7 @@ export function resolveByHashPrefix(
   if (matches.length === 0) {
     return notOk(
       errorRuntime('No migration found matching prefix', {
-        why: `No attested migration has a migrationId starting with "${normalizedPrefix}"`,
+        why: `No migration has a migrationId starting with "${normalizedPrefix}"`,
         fix: 'Run `prisma-next migration show` (no argument) to see the latest migration, or check the migrations directory for available packages.',
       }),
     );
@@ -132,16 +131,7 @@ async function executeMigrationShowCommand(
         if (!resolved.ok) return resolved;
         pkg = resolved.value;
       } else {
-        const attested = allPackages.filter(isAttested);
-        if (attested.length === 0) {
-          return notOk(
-            errorRuntime('No attested migrations found', {
-              why: `All migrations in ${migrationsRelative} are drafts (migrationId: null)`,
-              fix: 'Run `prisma-next migration emit --dir <path>` to attest a draft migration.',
-            }),
-          );
-        }
-        const graph = reconstructGraph(attested);
+        const graph = reconstructGraph(allPackages);
         const latestMigration = findLatestMigration(graph);
         if (!latestMigration) {
           return notOk(
@@ -151,7 +141,7 @@ async function executeMigrationShowCommand(
             }),
           );
         }
-        const leafPkg = attested.find(
+        const leafPkg = allPackages.find(
           (p) => p.manifest.migrationId === latestMigration.migrationId,
         );
         if (!leafPkg) {

package/src/commands/migration-status.ts

@@ -8,8 +8,7 @@ import {
 import type { Refs } from '@prisma-next/migration-tools/refs';
 import { readRefs, resolveRef } from '@prisma-next/migration-tools/refs';
 import type {
-  AttestedMigrationBundle,
-  DraftMigrationBundle,
+  MigrationBundle,
   MigrationChainEntry,
   MigrationGraph,
 } from '@prisma-next/migration-tools/types';
@@ -62,7 +61,7 @@ export interface MigrationStatusEntry {
   readonly dirName: string;
   readonly from: string;
   readonly to: string;
-  readonly migrationId: string | null;
+  readonly migrationId: string;
   readonly operationCount: number;
   readonly operationSummary: string;
   readonly hasDestructive: boolean;
@@ -87,7 +86,7 @@ export interface MigrationStatusResult {
     readonly refName?: string;
     readonly selectedPath: readonly {
       readonly dirName: string;
-      readonly migrationId: string | null;
+      readonly migrationId: string;
       readonly from: string;
       readonly to: string;
     }[];
@@ -95,8 +94,7 @@ export interface MigrationStatusResult {
   readonly summary: string;
   readonly diagnostics: readonly StatusDiagnostic[];
   readonly graph?: MigrationGraph;
-  readonly bundles?: readonly AttestedMigrationBundle[];
-  readonly drafts?: readonly DraftMigrationBundle[];
+  readonly bundles?: readonly MigrationBundle[];
   readonly edgeStatuses?: readonly EdgeStatus[];
   readonly activeRefHash?: string;
   readonly activeRefName?: string;
@@ -227,7 +225,7 @@ export function deriveEdgeStatuses(
  */
 function buildMigrationEntries(
   chain: readonly MigrationChainEntry[],
-  packages: readonly AttestedMigrationBundle[],
+  packages: readonly MigrationBundle[],
   mode: 'online' | 'offline',
   markerHash: string | undefined,
   edgeStatuses?: readonly EdgeStatus[],
@@ -436,11 +434,10 @@ async function executeMigrationStatusCommand(
     });
   }
 
-  let attested: readonly AttestedMigrationBundle[];
-  let drafts: readonly DraftMigrationBundle[];
+  let bundles: readonly MigrationBundle[];
   let graph: MigrationGraph;
   try {
-    ({ attested, drafts, graph } = await loadAllBundles(migrationsDir));
+    ({ bundles, graph } = await loadAllBundles(migrationsDir));
   } catch (error) {
     if (MigrationToolsError.is(error)) {
       return notOk(
@@ -454,18 +451,7 @@ async function executeMigrationStatusCommand(
     );
   }
 
-  if (drafts.length > 0) {
-    diagnostics.push({
-      code: 'MIGRATION.DRAFTS',
-      severity: 'warn',
-      message: `${drafts.length} draft migration(s) found: ${drafts.map((d) => d.dirName).join(', ')}`,
-      hints: [
-        "Run 'prisma-next migration emit --dir <path>' to attest draft migrations before applying",
-      ],
-    });
-  }
-
-  if (attested.length === 0) {
+  if (bundles.length === 0) {
     if (contractHash !== EMPTY_CONTRACT_HASH) {
       diagnostics.push({
         code: 'CONTRACT.AHEAD',
@@ -576,7 +562,7 @@ async function executeMigrationStatusCommand(
       migrations: [],
       targetHash: EMPTY_CONTRACT_HASH,
       contractHash,
-      summary: `${attested.length} migration(s) on disk`,
+      summary: `${bundles.length} migration(s) on disk`,
       diagnostics,
       markerHash,
       ...(statusRefs.length > 0 ? { refs: statusRefs } : {}),
@@ -616,12 +602,12 @@ async function executeMigrationStatusCommand(
       migrations: [],
       targetHash: EMPTY_CONTRACT_HASH,
       contractHash,
-      summary: `${attested.length} migration(s) on disk`,
+      summary: `${bundles.length} migration(s) on disk`,
       diagnostics,
       ...ifDefined('markerHash', markerHash),
       ...(statusRefs.length > 0 ? { refs: statusRefs } : {}),
       graph,
-      bundles: attested,
+      bundles,
       diverged: true,
     });
   }
@@ -638,7 +624,7 @@ async function executeMigrationStatusCommand(
   }
 
   const edgeStatuses = deriveEdgeStatuses(graph, targetHash, contractHash, markerHash, mode);
-  const entries = buildMigrationEntries(chain, attested, mode, markerHash, edgeStatuses);
+  const entries = buildMigrationEntries(chain, bundles, mode, markerHash, edgeStatuses);
 
   const pendingCount = edgeStatuses.filter((e) => e.status === 'pending').length;
   const appliedCount = edgeStatuses.filter((e) => e.status === 'applied').length;
@@ -646,7 +632,7 @@ async function executeMigrationStatusCommand(
   let summary: string;
   if (mode === 'online') {
     if (markerHash !== undefined && !graph.nodes.has(markerHash) && markerHash === contractHash) {
-      summary = `${attested.length} migration(s) on disk`;
+      summary = `${bundles.length} migration(s) on disk`;
     } else if (activeRefHash && markerHash !== undefined) {
       summary = summarizeRefDistance(graph, markerHash, activeRefHash, activeRefName!);
     } else if (pendingCount === 0) {
@@ -706,8 +692,7 @@ async function executeMigrationStatusCommand(
     ...(statusRefs.length > 0 ? { refs: statusRefs } : {}),
     ...ifDefined('pathDecision', pathDecision),
     graph,
-    bundles: attested,
-    ...(drafts.length > 0 ? { drafts } : {}),
+    bundles,
     edgeStatuses,
     ...ifDefined('activeRefHash', activeRefHash),
     ...ifDefined('activeRefName', activeRefName),
@@ -768,11 +753,6 @@ export function createMigrationStatusCommand(): Command {
               activeRefHash: statusResult.activeRefHash,
               activeRefName: statusResult.activeRefName,
               edgeStatuses: statusResult.edgeStatuses,
-              draftEdges: statusResult.drafts?.map((d) => ({
-                from: d.manifest.from,
-                to: d.manifest.to,
-                dirName: d.dirName,
-              })),
             });
 
             const graphToRender =

package/src/config-loader.ts

@@ -1,4 +1,3 @@
-import { dirname, resolve } from 'node:path';
 import type { PrismaNextConfig } from '@prisma-next/config/config-types';
 import { ConfigValidationError, validateConfig } from '@prisma-next/config/config-validation';
 import {
@@ -6,7 +5,41 @@ import {
   errorConfigValidation,
   errorUnexpected,
 } from '@prisma-next/errors/control';
+import { ifDefined } from '@prisma-next/utils/defined';
 import { loadConfig as loadConfigC12 } from 'c12';
+import { dirname, resolve } from 'pathe';
+import { finalizeConfig } from './config-path-validation';
+
+async function loadValidatedConfig(configPath?: string): Promise<PrismaNextConfig> {
+  const cwd = process.cwd();
+  const resolvedConfigPath = configPath ? resolve(cwd, configPath) : undefined;
+  const configCwd = resolvedConfigPath ? dirname(resolvedConfigPath) : cwd;
+
+  const result = await loadConfigC12<PrismaNextConfig>({
+    name: 'prisma-next',
+    ...ifDefined('configFile', resolvedConfigPath),
+    cwd: configCwd,
+  });
+
+  // When a specific config file was requested, verify it was actually loaded
+  // (c12 falls back to searching by name if the specified file doesn't exist)
+  if (resolvedConfigPath && result.configFile !== resolvedConfigPath) {
+    throw errorConfigFileNotFound(resolvedConfigPath);
+  }
+
+  // Check if config is missing or empty (c12 may return empty object when file doesn't exist)
+  if (!result.config || Object.keys(result.config).length === 0) {
+    // Use c12's configFile if available, otherwise use explicit configPath, otherwise omit path
+    const displayPath = result.configFile || resolvedConfigPath || configPath;
+    throw errorConfigFileNotFound(displayPath);
+  }
+
+  // Validate config structure
+  validateConfig(result.config);
+
+  const loadedConfigDir = result.configFile ? dirname(result.configFile) : configCwd;
+  return finalizeConfig(result.config, loadedConfigDir);
+}
 
 /**
  * Loads the Prisma Next config from a TypeScript file.
@@ -19,34 +52,7 @@ import { loadConfig as loadConfigC12 } from 'c12';
  */
 export async function loadConfig(configPath?: string): Promise<PrismaNextConfig> {
   try {
-    const cwd = process.cwd();
-    // Resolve config path to absolute path and set cwd to config directory when path is provided
-    const resolvedConfigPath = configPath ? resolve(cwd, configPath) : undefined;
-    const configCwd = resolvedConfigPath ? dirname(resolvedConfigPath) : cwd;
-
-    const result = await loadConfigC12<PrismaNextConfig>({
-      name: 'prisma-next',
-      ...(resolvedConfigPath ? { configFile: resolvedConfigPath } : {}),
-      cwd: configCwd,
-    });
-
-    // When a specific config file was requested, verify it was actually loaded
-    // (c12 falls back to searching by name if the specified file doesn't exist)
-    if (resolvedConfigPath && result.configFile !== resolvedConfigPath) {
-      throw errorConfigFileNotFound(resolvedConfigPath);
-    }
-
-    // Check if config is missing or empty (c12 may return empty object when file doesn't exist)
-    if (!result.config || Object.keys(result.config).length === 0) {
-      // Use c12's configFile if available, otherwise use explicit configPath, otherwise omit path
-      const displayPath = result.configFile || resolvedConfigPath || configPath;
-      throw errorConfigFileNotFound(displayPath);
-    }
-
-    // Validate config structure
-    validateConfig(result.config);
-
-    return result.config;
+    return await loadValidatedConfig(configPath);
   } catch (error) {
     if (error instanceof ConfigValidationError) {
       throw errorConfigValidation(error.field, {

package/src/config-path-validation.ts

@@ -0,0 +1,75 @@
+import {
+  type ContractSourceProvider,
+  normalizeContractConfig,
+  type PrismaNextConfig,
+} from '@prisma-next/config/config-types';
+import { ConfigValidationError } from '@prisma-next/config/config-validation';
+import { getEmittedArtifactPaths } from '@prisma-next/emitter';
+import { resolve } from 'pathe';
+
+function throwValidation(field: string, why: string): never {
+  throw new ConfigValidationError(field, why);
+}
+
+function finalizeContractSource(
+  source: ContractSourceProvider,
+  configDir: string,
+): ContractSourceProvider {
+  const resolvedInputs = source.inputs?.map((input) => resolve(configDir, input));
+  if (resolvedInputs === undefined) {
+    return source;
+  }
+
+  return {
+    ...source,
+    inputs: resolvedInputs,
+  };
+}
+
+function validateNoOutputsAreInputs(
+  inputs: readonly string[] | undefined,
+  output: string | undefined,
+): void {
+  if (inputs === undefined || output === undefined) {
+    return;
+  }
+
+  let emittedArtifactPaths: ReturnType<typeof getEmittedArtifactPaths>;
+  try {
+    emittedArtifactPaths = getEmittedArtifactPaths(output);
+  } catch (error) {
+    throwValidation('contract.output', error instanceof Error ? error.message : String(error));
+  }
+
+  const emittedPaths = new Set([emittedArtifactPaths.jsonPath, emittedArtifactPaths.dtsPath]);
+
+  for (const input of inputs) {
+    if (emittedPaths.has(input)) {
+      throwValidation(
+        'contract.source.inputs[]',
+        'Config.contract.source.inputs must not include emitted artifact paths derived from contract.output',
+      );
+    }
+  }
+}
+
+export function finalizeConfig(config: PrismaNextConfig, configDir: string): PrismaNextConfig {
+  if (!config.contract) {
+    return config;
+  }
+
+  const contract = normalizeContractConfig(config.contract);
+  const source = finalizeContractSource(contract.source, configDir);
+  const output = resolve(configDir, contract.output);
+
+  validateNoOutputsAreInputs(source.inputs, output);
+
+  return {
+    ...config,
+    contract: {
+      ...contract,
+      source,
+      output,
+    },
+  };
+}

package/src/control-api/client.ts

@@ -496,8 +496,9 @@ class ControlClientImpl implements ControlClient {
         authoringContributions: stack.authoringContributions,
         codecLookup: stack.codecLookup,
         controlMutationDefaults: stack.controlMutationDefaults,
+        resolvedInputs: contractConfig.source.inputs ?? [],
       };
-      const providerResult = await contractConfig.sourceProvider(sourceContext);
+      const providerResult = await contractConfig.source.load(sourceContext);
       if (!providerResult.ok) {
         onProgress?.({
           action: 'emit',

package/src/control-api/operations/contract-emit.ts

@@ -1,10 +1,10 @@
 import { mkdir, writeFile } from 'node:fs/promises';
 import type { Contract } from '@prisma-next/contract/types';
-import { emit } from '@prisma-next/emitter';
+import { emit, getEmittedArtifactPaths } from '@prisma-next/emitter';
 import { createControlStack } from '@prisma-next/framework-components/control';
 import { abortable } from '@prisma-next/utils/abortable';
 import { ifDefined } from '@prisma-next/utils/defined';
-import { dirname, isAbsolute, join, resolve } from 'pathe';
+import { dirname } from 'pathe';
 import { loadConfig } from '../../config-loader';
 import { errorContractConfigMissing, errorRuntime } from '../../utils/cli-errors';
 import { assertFrameworkComponentsCompatible } from '../../utils/framework-components';
@@ -72,27 +72,23 @@ export async function executeContractEmit(
       why: 'Contract config must have output path. This should not happen if defineConfig() was used.',
     });
   }
-  if (!contractConfig.output.endsWith('.json')) {
+
+  // Validate source exists and is callable
+  if (typeof contractConfig.source?.load !== 'function') {
     throw errorContractConfigMissing({
-      why: 'Contract config output path must end with .json (e.g., "src/prisma/contract.json")',
+      why: 'Contract config must include a valid source provider object',
     });
   }
 
-  // Validate source exists and is callable
-  if (typeof contractConfig.source !== 'function') {
+  let outputPaths: ReturnType<typeof getEmittedArtifactPaths>;
+  try {
+    outputPaths = getEmittedArtifactPaths(contractConfig.output);
+  } catch (error) {
     throw errorContractConfigMissing({
-      why: 'Contract config must include a valid source provider function',
+      why: error instanceof Error ? error.message : String(error),
     });
   }
-
-  // Normalize configPath and resolve artifact paths relative to config file directory
-  const normalizedConfigPath = resolve(configPath);
-  const configDir = dirname(normalizedConfigPath);
-  const outputJsonPath = isAbsolute(contractConfig.output)
-    ? contractConfig.output
-    : join(configDir, contractConfig.output);
-  // Colocate .d.ts with .json (contract.json → contract.d.ts)
-  const outputDtsPath = `${outputJsonPath.slice(0, -5)}.d.ts`;
+  const { jsonPath: outputJsonPath, dtsPath: outputDtsPath } = outputPaths;
 
   const stack = createControlStack(config);
 
@@ -102,39 +98,40 @@ export async function executeContractEmit(
     authoringContributions: stack.authoringContributions,
     codecLookup: stack.codecLookup,
     controlMutationDefaults: stack.controlMutationDefaults,
+    resolvedInputs: contractConfig.source.inputs ?? [],
   };
 
-  let providerResult: Awaited<ReturnType<typeof contractConfig.source>>;
+  let providerResult: Awaited<ReturnType<typeof contractConfig.source.load>>;
   try {
-    providerResult = await unlessAborted(contractConfig.source(sourceContext));
+    providerResult = await unlessAborted(contractConfig.source.load(sourceContext));
   } catch (error) {
     if (signal.aborted || isAbortError(error)) {
       throw error;
     }
     throw errorRuntime('Failed to resolve contract source', {
       why: error instanceof Error ? error.message : String(error),
-      fix: 'Ensure contract.source resolves to ok(Contract) or returns structured diagnostics.',
+      fix: 'Ensure contract.source.load resolves to ok(Contract) or returns structured diagnostics.',
     });
   }
 
   if (!isRecord(providerResult) || typeof providerResult.ok !== 'boolean') {
     throw errorRuntime('Failed to resolve contract source', {
       why: 'Contract source provider returned malformed result shape.',
-      fix: 'Ensure contract.source resolves to ok(Contract) or notOk({ summary, diagnostics }).',
+      fix: 'Ensure contract.source.load resolves to ok(Contract) or notOk({ summary, diagnostics }).',
     });
   }
 
   if (providerResult.ok && !('value' in providerResult)) {
     throw errorRuntime('Failed to resolve contract source', {
       why: 'Contract source provider returned malformed success result: missing value.',
-      fix: 'Ensure contract.source success payload is ok(Contract).',
+      fix: 'Ensure contract.source.load success payload is ok(Contract).',
     });
   }
 
   if (!providerResult.ok && !isProviderFailureLike(providerResult.failure)) {
     throw errorRuntime('Failed to resolve contract source', {
       why: 'Contract source provider returned malformed failure result: expected summary and diagnostics.',
-      fix: 'Ensure contract.source failure payload is notOk({ summary, diagnostics, meta? }).',
+      fix: 'Ensure contract.source.load failure payload is notOk({ summary, diagnostics, meta? }).',
     });
   }
 
@@ -160,7 +157,11 @@ export async function executeContractEmit(
   const enrichedIR = enrichContract(providerResult.value as Contract, frameworkComponents);
 
   familyInstance.validateContract(enrichedIR);
-  const emitResult = await unlessAborted(emit(enrichedIR, stack, config.family.emission));
+  const emitResult = await unlessAborted(
+    emit(enrichedIR, stack, config.family.emission, {
+      outputJsonPath: outputJsonPath,
+    }),
+  );
 
   // Create directory if needed and write files (both colocated)
   await unlessAborted(mkdir(dirname(outputJsonPath), { recursive: true }));

package/src/control-api/types.ts

@@ -248,7 +248,7 @@ export interface EmitContractConfig {
   /**
    * Contract source provider.
    */
-  readonly sourceProvider: ContractSourceProvider;
+  readonly source: ContractSourceProvider;
   /**
    * Output path for contract.json.
    * The .d.ts types file will be colocated (e.g., contract.json → contract.d.ts).

package/src/utils/command-helpers.ts

@@ -4,12 +4,7 @@ import { hasMigrations } from '@prisma-next/framework-components/control';
 import type { PathDecision } from '@prisma-next/migration-tools/dag';
 import { reconstructGraph } from '@prisma-next/migration-tools/dag';
 import { readMigrationsDir } from '@prisma-next/migration-tools/io';
-import type {
-  AttestedMigrationBundle,
-  DraftMigrationBundle,
-  MigrationGraph,
-} from '@prisma-next/migration-tools/types';
-import { isAttested, isDraft } from '@prisma-next/migration-tools/types';
+import type { MigrationBundle, MigrationGraph } from '@prisma-next/migration-tools/types';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type { Command } from 'commander';
 import { relative, resolve } from 'pathe';
@@ -150,32 +145,33 @@ export function getTargetMigrations(target: ControlTargetDescriptor<string, stri
 }
 
 /**
- * Reads the migrations directory, filters to attested bundles, and builds
- * the migration graph. Throws on I/O or graph errors — callers handle
- * error mapping.
+ * Reads the migrations directory and builds the migration graph from all
+ * bundles. Throws on I/O or graph errors — callers handle error mapping.
+ *
+ * Every on-disk bundle is content-addressed (`migrationId` is always a
+ * string); there is no draft state to filter out.
  */
 export async function loadMigrationBundles(migrationsDir: string): Promise<{
-  bundles: readonly AttestedMigrationBundle[];
+  bundles: readonly MigrationBundle[];
   graph: MigrationGraph;
 }> {
-  const allBundles = await readMigrationsDir(migrationsDir);
-  const bundles = allBundles.filter(isAttested);
+  const bundles = await readMigrationsDir(migrationsDir);
   const graph = reconstructGraph(bundles);
   return { bundles, graph };
 }
 
 export interface MigrationBundleSet {
-  readonly attested: readonly AttestedMigrationBundle[];
-  readonly drafts: readonly DraftMigrationBundle[];
+  readonly bundles: readonly MigrationBundle[];
   readonly graph: MigrationGraph;
 }
 
+/**
+ * Alias of `loadMigrationBundles` retained for naming-clarity in commands
+ * that previously needed both attested and draft splits. With the
+ * collapse of the draft state, both helpers do the same thing.
+ */
 export async function loadAllBundles(migrationsDir: string): Promise<MigrationBundleSet> {
-  const all = await readMigrationsDir(migrationsDir);
-  const attested = all.filter(isAttested);
-  const drafts = all.filter(isDraft);
-  const graph = reconstructGraph(attested);
-  return { attested, drafts, graph };
+  return loadMigrationBundles(migrationsDir);
 }
 
 /**

package/src/utils/formatters/graph-migration-mapper.ts

@@ -39,12 +39,6 @@ export interface EdgeStatus {
   readonly status: EdgeStatusKind;
 }
 
-export interface DraftEdge {
-  readonly from: string;
-  readonly to: string;
-  readonly dirName: string;
-}
-
 export interface MigrationGraphInput {
   readonly graph: MigrationGraph;
   readonly mode: 'online' | 'offline';
@@ -58,8 +52,6 @@ export interface MigrationGraphInput {
    * icons (✓/⧗) are baked into edge labels. Undefined in offline mode.
    */
   readonly edgeStatuses?: readonly EdgeStatus[] | undefined;
-  /** Draft migrations to render as dashed edges. */
-  readonly draftEdges?: readonly DraftEdge[] | undefined;
 }
 
 export interface MigrationRenderInput {
@@ -204,7 +196,9 @@ export function migrationGraphToRenderInput(input: MigrationGraphInput): Migrati
     spineTargetHash = lastEdge?.to ?? EMPTY_CONTRACT_HASH;
   }
 
-  // Contract not in attested graph — connect from spine target with a dashed edge
+  // Contract not in the migration graph — connect from spine target with a
+  // dashed edge so the user can see the gap (contract has changed but no
+  // migration has been planned yet).
   if (contractHash !== EMPTY_CONTRACT_HASH && !graph.nodes.has(contractHash)) {
     const contractMarkers: NodeMarker[] = [];
     if (mode === 'online' && markerHash === contractHash) {
@@ -216,13 +210,10 @@ export function migrationGraphToRenderInput(input: MigrationGraphInput): Migrati
       markers: contractMarkers,
     });
 
-    const matchingDraft = input.draftEdges?.find((d) => d.to === contractHash);
-    const fromHash = matchingDraft?.from ?? spineTargetHash;
-    if (graph.nodes.has(fromHash) || fromHash === spineTargetHash) {
+    if (graph.nodes.has(spineTargetHash) || spineTargetHash === EMPTY_CONTRACT_HASH) {
       edgeList.push({
-        from: toShortId(fromHash),
+        from: toShortId(spineTargetHash),
         to: shortHash(contractHash),
-        ...ifDefined('label', matchingDraft ? `${matchingDraft.dirName} [draft]` : undefined),
         style: 'dashed',
       });
     }

package/src/utils/formatters/help.ts

@@ -137,7 +137,6 @@ function getCommandDocsUrl(commandPath: string): string | undefined {
     'migration apply': 'https://pris.ly/migration-apply',
     'migration show': 'https://pris.ly/migration-show',
     'migration status': 'https://pris.ly/migration-status',
-    'migration emit': 'https://pris.ly/migration-emit',
   };
   return docsMap[commandPath];
 }

package/src/utils/formatters/migrations.ts

@@ -136,10 +136,6 @@ export interface MigrationApplyCommandOutputResult {
   };
 }
 
-export interface MigrationEmitCommandOutputResult {
-  readonly migrationId: string;
-}
-
 export function formatMigrationApplyCommandOutput(
   result: MigrationApplyCommandOutputResult,
   flags: GlobalFlags,
@@ -182,31 +178,12 @@ export function formatMigrationApplyCommandOutput(
   return lines.join('\n');
 }
 
-export function formatMigrationEmitCommandOutput(
-  result: MigrationEmitCommandOutputResult,
-  flags: GlobalFlags,
-): string {
-  if (flags.quiet) {
-    return '';
-  }
-
-  const lines: string[] = [];
-  const useColor = flags.color !== false;
-  const formatGreen = createColorFormatter(useColor, green);
-  const formatDimText = (text: string) => formatDim(useColor, text);
-
-  lines.push(`${formatGreen('✔')} Emitted ops.json and attested migration`);
-  lines.push(formatDimText(`  migrationId: ${result.migrationId}`));
-
-  return lines.join('\n');
-}
-
 interface MigrationShowResult {
   readonly dirName: string;
   readonly dirPath: string;
   readonly from: string;
   readonly to: string;
-  readonly migrationId: string | null;
+  readonly migrationId: string;
   readonly kind: string;
   readonly createdAt: string;
   readonly operations: readonly {
@@ -234,11 +211,7 @@ export function formatMigrationShowOutput(result: MigrationShowResult, flags: Gl
   lines.push(`${formatDimText(`  kind: ${result.kind}`)}`);
   lines.push(`${formatDimText(`  from: ${result.from}`)}`);
   lines.push(`${formatDimText(`  to:   ${result.to}`)}`);
-  if (result.migrationId) {
-    lines.push(`${formatDimText(`  migrationId: ${result.migrationId}`)}`);
-  } else {
-    lines.push(`${formatYellow('  migrationId: (draft — not yet attested)')}`);
-  }
+  lines.push(`${formatDimText(`  migrationId: ${result.migrationId}`)}`);
   lines.push(`${formatDimText(`  created: ${result.createdAt}`)}`);
 
   lines.push('');