@prisma-next/cli 0.14.0-dev.39 → 0.14.0-dev.40

package/src/commands/migrate.ts

@@ -2,7 +2,10 @@ import { readFile } from 'node:fs/promises';
 import { loadConfig } from '@prisma-next/config-loader';
 import type { Contract } from '@prisma-next/contract/types';
 import { createControlStack } from '@prisma-next/framework-components/control';
-import { type ContractSpaceMember, requireHeadRef } from '@prisma-next/migration-tools/aggregate';
+import {
+  type AggregateContractSpace,
+  requireHeadRef,
+} from '@prisma-next/migration-tools/aggregate';
 import { EMPTY_CONTRACT_HASH } from '@prisma-next/migration-tools/constants';
 import { errorUnknownInvariant, MigrationToolsError } from '@prisma-next/migration-tools/errors';
 import { findLatestMigration, isGraphNode } from '@prisma-next/migration-tools/migration-graph';
@@ -13,7 +16,7 @@ import { ifDefined } from '@prisma-next/utils/defined';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { Command } from 'commander';
 import { createControlClient } from '../control-api/client';
-import { planMemberPath } from '../control-api/operations/migrate';
+import { planSpacePath } from '../control-api/operations/migrate';
 import type {
   MigrateFailure,
   MigratePathDecision,
@@ -149,7 +152,7 @@ export interface MigrateResult {
  * Computes the path through the SAME seam as `executeMigrate`:
  * - `readAllMarkers()` for the from-state (when no `--from` is given), preserving
  *   the full marker including `invariants` (not just `storageHash`).
- * - `planMemberPath()` (shared with `executeMigrate`) for per-member path selection,
+ * - `planSpacePath()` (shared with `executeMigrate`) for per-space path selection,
  *   which feeds `graphWalkStrategy()` with the same target hash, target invariants,
  *   and current marker as the real apply path uses.
  *
@@ -203,7 +206,7 @@ async function executeMigrateShowCommand(
   const appGraph = aggregate.app.graph();
 
   // Resolve the --to target (defaults to the on-disk contract, same as migrate).
-  // Also capture the ref's invariants so planMemberPath feeds graphWalkStrategy the
+  // Also capture the ref's invariants so planSpacePath feeds graphWalkStrategy the
   // same target invariants that real migrate would use (refInvariants ?? headRef.invariants).
   let targetHash: string = contractHash;
   let refInvariants: readonly string[] | undefined;
@@ -258,13 +261,13 @@ async function executeMigrateShowCommand(
   // - Explicit --from: parse it offline (no connection).
   // - Omitted: read the live DB marker via readAllMarkers() — the same source migrate uses.
   //
-  // Full marker records (storageHash + invariants) are preserved so planMemberPath
+  // Full marker records (storageHash + invariants) are preserved so planSpacePath
   // can feed graphWalkStrategy the complete currentMarker — exactly as executeMigrate
   // does via familyInstance.readAllMarkers(). A stripped { storageHash, invariants: [] }
   // marker would produce a different `required` set and a different (incorrect) path.
   type LiveMarker = { readonly storageHash: string; readonly invariants: readonly string[] };
   const markerBySpace = new Map<string, LiveMarker | null>();
-  const allMembers: ReadonlyArray<ContractSpaceMember> = [aggregate.app, ...aggregate.extensions];
+  const allSpaces: ReadonlyArray<AggregateContractSpace> = [aggregate.app, ...aggregate.extensions];
 
   if (hasExplicitFrom) {
     // @db with explicit --from requires a connection
@@ -301,7 +304,7 @@ async function executeMigrateShowCommand(
       } else {
         // Offline hypothetical: the --from ref only carries a hash (no live invariants).
         // Apply the from-hash marker to the APP space only. Extension spaces are left
-        // absent from markerBySpace (treated as null / greenfield by planMemberPath),
+        // absent from markerBySpace (treated as null / greenfield by planSpacePath),
         // so they plan from their own marker → own head — exactly as executeMigrate does.
         const fromHash = fromResult.value.hash;
         const offlineMarker: LiveMarker | null =
@@ -334,9 +337,9 @@ async function executeMigrateShowCommand(
       const allMarkers = await client.readAllMarkers();
       // Store the full marker record (storageHash + invariants) per space.
       // This is the same data executeMigrate uses via familyInstance.readAllMarkers().
-      for (const member of allMembers) {
-        const marker = allMarkers.get(member.spaceId);
-        markerBySpace.set(member.spaceId, marker ?? null);
+      for (const space of allSpaces) {
+        const marker = allMarkers.get(space.spaceId);
+        markerBySpace.set(space.spaceId, marker ?? null);
       }
     } catch (error) {
       if (CliStructuredError.is(error)) {
@@ -355,35 +358,35 @@ async function executeMigrateShowCommand(
     }
   }
 
-  // Walk the path via planMemberPath — the same helper executeMigrate uses.
-  // planMemberPath feeds graphWalkStrategy identical inputs (targetHash, targetInvariants,
+  // Walk the path via planSpacePath — the same helper executeMigrate uses.
+  // planSpacePath feeds graphWalkStrategy identical inputs (targetHash, targetInvariants,
   // currentMarker with full invariants), so the preview path is always the path migrate runs.
   //
   // Canonical schedule order: extensions alphabetically first, then app — mirroring the
   // runner's `applyOrder` in operations/migrate.ts so the "Will run, in order:" list
   // reflects the actual execution sequence (extensions install first, app last).
-  const canonicalOrderMembers: ReadonlyArray<ContractSpaceMember> = [
+  const canonicalOrderSpaces: ReadonlyArray<AggregateContractSpace> = [
     ...aggregate.extensions,
     aggregate.app,
   ];
   const orderedMigrations: MigrateShowMigration[] = [];
-  for (const member of canonicalOrderMembers) {
-    const isAppMember = member.spaceId === aggregate.app.spaceId;
-    const headRef = requireHeadRef(member);
-    const memberTargetHash = isAppMember ? targetHash : headRef.hash;
-    const memberRefInvariants = isAppMember ? refInvariants : undefined;
-    const liveMarker = markerBySpace.get(member.spaceId) ?? null;
-
-    const outcome = planMemberPath({
-      member,
+  for (const space of canonicalOrderSpaces) {
+    const isAppSpace = space.spaceId === aggregate.app.spaceId;
+    const headRef = requireHeadRef(space);
+    const spaceTargetHash = isAppSpace ? targetHash : headRef.hash;
+    const spaceRefInvariants = isAppSpace ? refInvariants : undefined;
+    const liveMarker = markerBySpace.get(space.spaceId) ?? null;
+
+    const outcome = planSpacePath({
+      space,
       aggregate,
-      targetHash: memberTargetHash,
-      refInvariants: memberRefInvariants,
+      targetHash: spaceTargetHash,
+      refInvariants: spaceRefInvariants,
       liveMarker,
     });
 
     if (outcome.kind === 'at-head') {
-      // Empty-graph member already at target — nothing to run for this space.
+      // Empty-graph space already at target — nothing to run for this space.
       continue;
     }
     if (outcome.kind === 'never-planned') {
@@ -417,7 +420,7 @@ async function executeMigrateShowCommand(
 
     for (const edge of outcome.plan.migrationEdges) {
       orderedMigrations.push({
-        spaceId: member.spaceId,
+        spaceId: space.spaceId,
         dirName: edge.dirName,
         migrationHash: edge.migrationHash,
         from: edge.from,
@@ -445,12 +448,12 @@ async function executeMigrateShowCommand(
     // before rendering. This ensures the name column, hash column, and ops column
     // start at the same horizontal offset across every space section AND the
     // "Will run, in order:" list below.
-    const memberLayouts = allMembers.map((member) => {
-      const isApp = member.spaceId === aggregate.app.spaceId;
-      const memberGraph = member.graph();
-      const rowModel = buildMigrationGraphRows(memberGraph, isApp ? { contractHash } : {});
+    const spaceLayouts = allSpaces.map((space) => {
+      const isApp = space.spaceId === aggregate.app.spaceId;
+      const spaceGraph = space.graph();
+      const rowModel = buildMigrationGraphRows(spaceGraph, isApp ? { contractHash } : {});
       const edgeAnnotations = new Map<string, MigrationEdgeAnnotation>();
-      for (const edge of memberGraph.migrationByHash.values()) {
+      for (const edge of spaceGraph.migrationByHash.values()) {
         edgeAnnotations.set(edge.migrationHash, {
           pathHighlight: onPathHashes.has(edge.migrationHash) ? 'on-path' : 'off-path',
         });
@@ -459,17 +462,17 @@ async function executeMigrateShowCommand(
       // green/continuous; off-path lanes dim. Rows, gutter, and labels all come
       // from this one grid.
       const grid = buildGrid(rowModel, {}, highlightFromEdgeAnnotations(edgeAnnotations));
-      return { member, isApp, memberGraph, rowModel, grid, edgeAnnotations };
+      return { space, isApp, spaceGraph, rowModel, grid, edgeAnnotations };
     });
 
     // Global max across all space grids so every section's labels share columns.
     const globalLabelColumn =
-      memberLayouts.length > 1
-        ? Math.max(...memberLayouts.map(({ grid }) => computeLabelColumn(grid, 'unicode')))
+      spaceLayouts.length > 1
+        ? Math.max(...spaceLayouts.map(({ grid }) => computeLabelColumn(grid, 'unicode')))
         : undefined;
     const globalMaxDirNameWidthFromLayouts =
-      memberLayouts.length > 1
-        ? Math.max(...memberLayouts.map(({ rowModel }) => computeMaxDirNameWidth(rowModel)))
+      spaceLayouts.length > 1
+        ? Math.max(...spaceLayouts.map(({ rowModel }) => computeMaxDirNameWidth(rowModel)))
         : undefined;
     // The run-list name column width must be at least as wide as the global tree dirName
     // width so that tree sections and the list align at the hash column.
@@ -485,10 +488,10 @@ async function executeMigrateShowCommand(
     runListLeftPad = globalLabelColumn;
 
     // Render each space section with globally computed widths.
-    const showSpaceHeadings = allMembers.length > 1;
+    const showSpaceHeadings = allSpaces.length > 1;
     const sections: string[] = [];
-    for (const { member, isApp, rowModel, grid, edgeAnnotations } of memberLayouts) {
-      const liveMarker = markerBySpace.get(member.spaceId) ?? null;
+    for (const { space, isApp, rowModel, grid, edgeAnnotations } of spaceLayouts) {
+      const liveMarker = markerBySpace.get(space.spaceId) ?? null;
       const liveMarkerHash = liveMarker?.storageHash ?? EMPTY_CONTRACT_HASH;
       const tree = renderMigrationGraphCommand({
         grid,
@@ -496,7 +499,7 @@ async function executeMigrateShowCommand(
         contractHash,
         isAppSpace: isApp,
         ...(needsLiveMarker ? { dbHash: liveMarkerHash } : {}),
-        refsByHash: listRefsByContractHash(member),
+        refsByHash: listRefsByContractHash(space),
         edgeAnnotationsByHash: edgeAnnotations,
         colorize,
         glyphMode: 'unicode',
@@ -505,7 +508,7 @@ async function executeMigrateShowCommand(
       });
       if (tree.length === 0) continue;
       if (showSpaceHeadings) {
-        sections.push(`${member.spaceId}:\n${indentMigrationGraphTreeBlock(tree, '  ')}`);
+        sections.push(`${space.spaceId}:\n${indentMigrationGraphTreeBlock(tree, '  ')}`);
       } else {
         sections.push(tree);
       }

package/src/commands/migration-check.ts

@@ -156,16 +156,16 @@ export async function enumerateCheckSpaces(
     candidateDirs.filter((name) => !RESERVED_SPACE_SUBDIR_NAMES.has(name)).filter(isValidSpaceId),
   );
   const spaces: CheckSpace[] = [];
-  for (const member of aggregate.spaces()) {
-    const spaceId = member.spaceId;
+  for (const space of aggregate.spaces()) {
+    const spaceId = space.spaceId;
     if (!isValidSpaceId(spaceId)) continue;
     if (!onDiskSpaceIds.has(spaceId)) continue;
     const migrationsDir = spaceMigrationDirectory(projectMigrationsDir, spaceId);
     spaces.push({
       spaceId,
-      packages: member.packages,
-      refs: member.refs,
-      graph: member.graph(),
+      packages: space.packages,
+      refs: space.refs,
+      graph: space.graph(),
       migrationsDir,
       refsDir: spaceRefsDirectory(migrationsDir),
     });

package/src/commands/migration-graph.ts

@@ -154,13 +154,13 @@ export async function executeMigrationGraphCommand(
   const treeSections: MigrationGraphTreeSection[] = [];
   const spaces: MigrationSpaceGraphEntry[] = [];
   for (const spaceEntry of scopedSpaces) {
-    const member = aggregate.space(spaceEntry.space);
-    if (member === undefined) {
+    const space = aggregate.space(spaceEntry.space);
+    if (space === undefined) {
       continue;
     }
-    const graph = member.graph();
+    const graph = space.graph();
     const isAppSpace = spaceEntry.space === aggregate.app.spaceId;
-    const refsByHash = listRefsByContractHash(member);
+    const refsByHash = listRefsByContractHash(space);
     const tree =
       spaceEntry.migrations.length === 0
         ? ''

package/src/commands/migration-list.ts

@@ -1,7 +1,7 @@
 import { loadConfig } from '@prisma-next/config-loader';
 import type {
+  AggregateContractSpace,
   ContractSpaceAggregate,
-  ContractSpaceMember,
 } from '@prisma-next/migration-tools/aggregate';
 import type { MigrationGraph } from '@prisma-next/migration-tools/graph';
 import { HEAD_REF_NAME, refsByContractHash } from '@prisma-next/migration-tools/refs';
@@ -59,18 +59,18 @@ function compareDirNamesDescending(a: MigrationListEntry, b: MigrationListEntry)
 
 /**
  * Ref names decorating a space's destination contract hashes. The
- * tolerant `member.refs` deliberately omits the structural `head.json`;
+ * tolerant `space.refs` deliberately omits the structural `head.json`;
  * for extension spaces the old enumerator surfaced it as a `head`
- * decoration on the tip migration, so fold `member.headRef` back in to
+ * decoration on the tip migration, so fold `space.headRef` back in to
  * keep that output. The app space synthesises its head, so it carries
  * no on-disk `head` ref to restore.
  */
 export function listRefsByContractHash(
-  member: ContractSpaceMember,
+  space: AggregateContractSpace,
 ): ReadonlyMap<string, readonly string[]> {
-  const byHash = new Map(refsByContractHash(member.refs));
-  if (member.spaceId !== APP_SPACE_ID && member.headRef !== null) {
-    const hash = member.headRef.hash;
+  const byHash = new Map(refsByContractHash(space.refs));
+  if (space.spaceId !== APP_SPACE_ID && space.headRef !== null) {
+    const hash = space.headRef.hash;
     const bucket = byHash.get(hash) ?? [];
     if (!bucket.includes(HEAD_REF_NAME)) {
       byHash.set(hash, [...bucket, HEAD_REF_NAME].sort());
@@ -92,7 +92,7 @@ async function orderedOnDiskSpaceIds(projectMigrationsDir: string): Promise<read
  * {@link MigrationSpaceListEntry} rows `migration list` displays.
  *
  * Space membership matches the on-disk contract-space directories (not the
- * aggregate's always-present synthesized app member when `migrations/app/`
+ * aggregate's always-present synthesized app space when `migrations/app/`
  * is absent); package and ref data come from `aggregate.space(id)`.
  */
 export async function migrationSpaceListEntriesFromAggregate(
@@ -103,12 +103,12 @@ export async function migrationSpaceListEntriesFromAggregate(
   const spaces: MigrationSpaceListEntry[] = [];
 
   for (const spaceId of spaceIds) {
-    const member = aggregate.space(spaceId);
-    if (member === undefined) {
+    const space = aggregate.space(spaceId);
+    if (space === undefined) {
       continue;
     }
-    const refsByHash = listRefsByContractHash(member);
-    const migrations: MigrationListEntry[] = member.packages
+    const refsByHash = listRefsByContractHash(space);
+    const migrations: MigrationListEntry[] = space.packages
       .map((pkg) => ({
         name: pkg.dirName,
         hash: pkg.metadata.migrationHash,

package/src/commands/migration-plan.ts

@@ -321,11 +321,11 @@ async function executeMigrationPlanCommand(
   if (!tolerantAggregateResult.ok) {
     return notOk(tolerantAggregateResult.failure);
   }
-  const resolutionMember = tolerantAggregateResult.value.app;
+  const resolutionSpace = tolerantAggregateResult.value.app;
 
   const resolutionResult = await resolveFromForPlan({
     optionsFrom: options.from,
-    member: resolutionMember,
+    space: resolutionSpace,
   });
 
   if (!resolutionResult.ok) {
@@ -365,7 +365,7 @@ async function executeMigrationPlanCommand(
   // change.
   if (options.to !== undefined) {
     const toResolution = await resolveToForPlan(options.to, {
-      member: resolutionMember,
+      space: resolutionSpace,
     });
     if (!toResolution.ok) {
       return notOk(toResolution.failure);

package/src/commands/migration-status.ts

@@ -1,8 +1,8 @@
 import { loadConfig } from '@prisma-next/config-loader';
 import type { LedgerEntryRecord } from '@prisma-next/contract/types';
 import type {
+  AggregateContractSpace,
   ContractMarkerRecordLike,
-  ContractSpaceMember,
 } from '@prisma-next/migration-tools/aggregate';
 import { EMPTY_CONTRACT_HASH } from '@prisma-next/migration-tools/constants';
 import {
@@ -130,7 +130,7 @@ function buildStatusMigrations(
 }
 
 function renderSpaceTree(args: {
-  readonly member: ContractSpaceMember;
+  readonly space: AggregateContractSpace;
   readonly liveContractHash: string;
   readonly migrations: readonly MigrationListEntry[];
   readonly markerHash: string | undefined;
@@ -142,7 +142,7 @@ function renderSpaceTree(args: {
   readonly globalMaxEdgeTreePrefixWidth?: number;
   readonly globalMaxDirNameWidth?: number;
 }): string {
-  const graph = args.member.graph();
+  const graph = args.space.graph();
   if (graph.nodes.size === 0) {
     return '';
   }
@@ -150,7 +150,7 @@ function renderSpaceTree(args: {
     graph,
     migrations: args.migrations,
     liveContractHash: args.liveContractHash,
-    refsByHash: listRefsByContractHash(args.member),
+    refsByHash: listRefsByContractHash(args.space),
     statusOverlayByHash: args.statusOverlay,
     colorize: args.colorize,
     glyphMode: args.glyphMode,
@@ -493,12 +493,12 @@ export async function executeMigrationStatusCommand(
     globalLayoutInputs.length > 0 ? computeGlobalMaxDirNameWidth(globalLayoutInputs) : undefined;
 
   for (const spaceEntry of scopedSpaces) {
-    const member = aggregate.space(spaceEntry.space);
-    if (member === undefined) {
+    const space = aggregate.space(spaceEntry.space);
+    if (space === undefined) {
       continue;
     }
-    const graph = member.graph();
-    const spaceContractHash = member.contract().storage.storageHash;
+    const graph = space.graph();
+    const spaceContractHash = space.contract().storage.storageHash;
     const targetHash = resolveTarget(spaceContractHash, activeRefHash);
     if (spaceEntry.space === aggregate.app.spaceId) {
       headlineTargetHash = targetHash;
@@ -547,7 +547,7 @@ export async function executeMigrationStatusCommand(
     });
     const isAppSpace = spaceEntry.space === aggregate.app.spaceId;
     const tree = renderSpaceTree({
-      member,
+      space,
       liveContractHash: contractHash,
       migrations: spaceEntry.migrations,
       markerHash,

package/src/control-api/operations/db-init.ts

@@ -20,7 +20,7 @@ import { executeRun } from './db-run';
  *    {@link import('@prisma-next/migration-tools/aggregate').loadContractSpaceAggregate}
  *    from the supplied descriptor set + on-disk on-disk artefacts.
  * 2. The aggregate planner runs with `callerPolicy.ignoreGraphFor`
- *    locked to the app member — synth strategy for the app, graph-walk
+ *    locked to the app space — synth strategy for the app, graph-walk
  *    for every extension.
  * 3. The runner's `execute` applies the per-space plans
  *    inside one outer transaction.
@@ -53,7 +53,7 @@ export interface ExecuteDbInitOptions<TFamilyId extends string, TTargetId extend
   /**
    * Declared extension descriptors. Defaults to an empty list, which
    * routes through the same loader → planner → runner pipeline with no
-   * extension members in the aggregate.
+   * extension spaces in the aggregate.
    */
   readonly extensionPacks?: ReadonlyArray<ControlExtensionDescriptor<TFamilyId, TTargetId>>;
   /** Optional progress callback for observing operation progress */

package/src/control-api/operations/db-run.ts

@@ -98,9 +98,9 @@ export interface ExecuteRunOptions<TFamilyId extends string, TTargetId extends s
  * 2. **Read DB state**: marker rows (`familyInstance.readAllMarkers`)
  *    + introspected schema (`familyInstance.introspect`).
  * 3. **Plan**: {@link planMigration} chooses graph-walk vs synth per
- *    member according to `callerPolicy.ignoreGraphFor`. The app member
+ *    space according to `callerPolicy.ignoreGraphFor`. The app space
  *    is forced through synth (today's daily-driver behaviour); every
- *    extension member walks its on-disk graph.
+ *    extension space walks its on-disk graph.
  * 4. **Apply** (when `mode === 'apply'`): every per-space `MigrationPlan`
  *    feeds into the runner's `execute` — one outer
  *    transaction across every space; failure on any space rolls back
@@ -200,7 +200,7 @@ export async function executeRun<TFamilyId extends string, TTargetId extends str
   const appResolution = orderedResolutions.find((r) => r.spaceId === aggregate.app.spaceId);
   if (!appResolution) {
     throw new Error(
-      'Aggregate planner returned no plan for the app member — the planner is supposed to always emit one.',
+      'Aggregate planner returned no plan for the app space — the planner is supposed to always emit one.',
     );
   }
   const appPlan = appResolution.entry.plan;
@@ -280,14 +280,14 @@ function aggregatePlannerWarnings(
 
 /**
  * Compare the live `_prisma_marker` rows against the aggregate's
- * declared members. Any marker row whose `space` is not a member of
+ * declared contract spaces. Any marker row whose `space` is not a space of
  * the aggregate is an "orphan" — typically a marker left behind by
  * an extension that was removed from `extensionPacks` without first
  * cleaning up its on-disk migrations / database tables.
  *
  * Returns a {@link CliStructuredError} envelope (code `5002`,
  * `kind: 'orphanMarker'`) for the first orphan it finds, or `null`
- * when every marker row maps to a declared member. Mirrors the M2
+ * when every marker row maps to a declared contract space. Mirrors the M2
  * `runContractSpaceVerifierMarkerCheck` envelope so downstream
  * tooling (integration tests, JSON consumers) keeps asserting on the
  * same shape.
@@ -296,13 +296,13 @@ function detectOrphanMarkers(
   aggregate: ContractSpaceAggregate,
   markerRows: ReadonlyMap<string, unknown>,
 ): CliStructuredError | null {
-  const memberSpaceIds = new Set<string>([
+  const aggregateSpaceIds = new Set<string>([
     aggregate.app.spaceId,
     ...aggregate.extensions.map((m) => m.spaceId),
   ]);
   const orphans: string[] = [];
   for (const [spaceId, row] of markerRows) {
-    if (row !== null && row !== undefined && !memberSpaceIds.has(spaceId)) {
+    if (row !== null && row !== undefined && !aggregateSpaceIds.has(spaceId)) {
       orphans.push(spaceId);
     }
   }

package/src/control-api/operations/db-verify.ts

@@ -7,13 +7,13 @@ import type {
   VerifyDatabaseSchemaResult,
 } from '@prisma-next/framework-components/control';
 import {
-  type ContractSpaceMember,
+  type AggregateContractSpace,
   collectAggregateNamespaces,
   requireHeadRef,
   type VerifierOutput,
   verifyMigration,
 } from '@prisma-next/migration-tools/aggregate';
-import { blindCast, castAs } from '@prisma-next/utils/casts';
+import { castAs } from '@prisma-next/utils/casts';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { CliStructuredError } from '../../utils/cli-errors';
 import {
@@ -37,9 +37,9 @@ const SPAN_IDS = {
  *
  * Loader → verifier pipeline. The loader (sole descriptor-import
  * boundary) builds a {@link import('@prisma-next/migration-tools/aggregate').ContractSpaceAggregate};
- * the aggregate verifier bundles `markerCheck` + per-space pre-projected
- * `schemaCheck`. `mode: 'strict' | 'lenient'` maps directly to the user
- * facing `--strict` flag.
+ * the aggregate verifier bundles `markerCheck` + per-space `schemaCheck`
+ * (each contract space verified against the full schema; extras stripped to its own view).
+ * `mode: 'strict' | 'lenient'` maps directly to the user facing `--strict` flag.
  */
 export interface ExecuteDbVerifyOptions<TFamilyId extends string, TTargetId extends string> {
   readonly driver: ControlDriverInstance<TFamilyId, TTargetId>;
@@ -63,13 +63,19 @@ export interface ExecuteDbVerifyOptions<TFamilyId extends string, TTargetId exte
  * emitted, so downstream tooling and integration tests assert on the
  * same shape).
  *
- * On success, the per-space schema results are returned for the CLI to
+ * On success, the per-space verify results are returned for the CLI to
  * render. When `skipSchema` is true (`--marker-only`), the schema map
  * is empty.
  */
 export interface ExecuteDbVerifySuccess {
   readonly schemaResults: ReadonlyMap<string, VerifyDatabaseSchemaResult>;
-  readonly memberOrder: readonly string[];
+  /**
+   * Live element names no contract space declares, deduplicated and reported
+   * once for the whole database (never per space). Strict mode fails on a
+   * non-empty list; lenient mode surfaces it informationally.
+   */
+  readonly unclaimed: readonly string[];
+  readonly spaceOrder: readonly string[];
   readonly appSpaceId: string;
 }
 
@@ -85,11 +91,11 @@ export type ExecuteDbVerifyResult = Result<ExecuteDbVerifySuccess, CliStructured
  *    structured CLI error.
  * 2. **Read DB state**: marker rows + (when `skipSchema` is `false`)
  *    schema introspection.
- * 3. **Verify**: {@link verifyMigration} returns per-space
- *    `markerCheck` + per-space pre-projected `schemaCheck` (closes F23).
- *    Marker mismatches map to `CliStructuredError` (code `5002`) so
- *    callers (CLI command) can render and exit. Schema results are
- *    returned to the caller verbatim.
+ * 3. **Verify**: {@link verifyMigration} returns per-space `markerCheck` +
+ *    per-space `schemaCheck` (each contract space verified against the full schema,
+ *    then scoped to its own contract space). Marker mismatches map to
+ *    `CliStructuredError` (code `5002`) so callers (CLI command) can render
+ *    and exit. Verify results are returned to the caller verbatim.
  */
 export async function executeDbVerify<TFamilyId extends string, TTargetId extends string>(
   options: ExecuteDbVerifyOptions<TFamilyId, TTargetId>,
@@ -115,7 +121,7 @@ export async function executeDbVerify<TFamilyId extends string, TTargetId extend
     markersBySpaceId,
     schemaIntrospection,
     mode: options.mode,
-    verifySchemaForMember: createPerMemberVerifier(options),
+    verifySchemaForSpace: createPerSpaceVerifier(options),
   });
   return finaliseVerifyResult({ verifyResult, aggregate, skipMarker, onProgress });
 }
@@ -166,30 +172,27 @@ async function runIntrospection<TFamilyId extends string, TTargetId extends stri
 }
 
 /**
- * Build the per-member schema callback handed to the aggregate verifier.
+ * Build the per-space schema callback handed to the aggregate verifier.
  * When `skipSchema` is true the callback short-circuits with a synthetic
  * `ok` result so the verifier still runs the (cheap) schemaCheck loop
  * without invoking the family's verification path.
  */
-export function createPerMemberVerifier<TFamilyId extends string, TTargetId extends string>(
+export function createPerSpaceVerifier<TFamilyId extends string, TTargetId extends string>(
   options: ExecuteDbVerifyOptions<TFamilyId, TTargetId>,
 ): (
-  projectedSchema: unknown,
-  member: ContractSpaceMember,
+  schema: unknown,
+  space: AggregateContractSpace,
   verifyMode: 'strict' | 'lenient',
 ) => VerifyDatabaseSchemaResult {
   const { skipSchema, familyInstance, frameworkComponents } = options;
-  return (projectedSchema, member, verifyMode) => {
-    if (skipSchema) return buildSkippedSchemaResult(member);
+  return (schema, space, verifyMode) => {
+    if (skipSchema) return buildSkippedSchemaResult(space);
     return familyInstance.verifySchema({
-      contract: member.contract(),
-      // The family's `TSchemaIR` is opaque to migration-tools; the
-      // aggregate verifier passes through whatever we hand it. The
-      // family expects its own IR shape on the way back.
-      schema: blindCast<
-        never,
-        'family TSchemaIR is opaque to migration-tools; projectedSchema is passed straight through'
-      >(projectedSchema),
+      contract: space.contract(),
+      // `familyInstance` is `ControlFamilyInstance<_, unknown>`, so `verifySchema`
+      // takes its `TSchemaIR` as `unknown` — the introspected schema passes
+      // straight through; the family narrows to its own IR node internally.
+      schema,
       strict: verifyMode === 'strict',
       frameworkComponents,
     });
@@ -223,7 +226,7 @@ function emitVerifySpan(
  * by the CLI's `--schema-only` mode.
  */
 function finaliseVerifyResult(args: {
-  verifyResult: VerifierOutput<VerifyDatabaseSchemaResult>;
+  verifyResult: VerifierOutput;
   aggregate: {
     readonly app: { readonly spaceId: string };
     readonly extensions: ReadonlyArray<{ readonly spaceId: string }>;
@@ -253,14 +256,15 @@ function finaliseVerifyResult(args: {
   emitVerifySpan(onProgress, 'spanEndOk');
   return ok({
     schemaResults: verifyResult.value.schemaCheck.perSpace,
-    memberOrder: [aggregate.app.spaceId, ...aggregate.extensions.map((e) => e.spaceId)],
+    unclaimed: verifyResult.value.schemaCheck.unclaimed,
+    spaceOrder: [aggregate.app.spaceId, ...aggregate.extensions.map((e) => e.spaceId)],
     appSpaceId: aggregate.app.spaceId,
   });
 }
 
-function buildSkippedSchemaResult(member: ContractSpaceMember): VerifyDatabaseSchemaResult {
-  const contract = member.contract();
-  const headRef = requireHeadRef(member);
+function buildSkippedSchemaResult(space: AggregateContractSpace): VerifyDatabaseSchemaResult {
+  const contract = space.contract();
+  const headRef = requireHeadRef(space);
   const profileHash = castAs<{ profileHash?: string }>(contract).profileHash;
   return {
     ok: true,
@@ -276,7 +280,7 @@ function buildSkippedSchemaResult(member: ContractSpaceMember): VerifyDatabaseSc
       root: {
         status: 'pass',
         kind: 'skipped',
-        name: member.spaceId,
+        name: space.spaceId,
         contractPath: '',
         code: 'SKIPPED',
         message: 'Schema verification skipped',