@prisma-next/cli 0.14.0-dev.5 → 0.14.0-dev.50

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

@@ -1,5 +1,5 @@
 /**
- * Backs `db init` / `db update`. Strategy: introspect → planMigration; synth-for-app + graph-walk-extensions; plan-mode + orphan-marker preflight.
+ * Backs `db init` / `db update`. Strategy: introspect → planMigration; planFromDiff-for-app + resolveRecordedPath-extensions; plan-mode + orphan-marker preflight.
  */
 
 import type { Contract } from '@prisma-next/contract/types';
@@ -97,10 +97,11 @@ export interface ExecuteRunOptions<TFamilyId extends string, TTargetId extends s
  *    integrity violation short-circuits with a structured error.
  * 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
- *    is forced through synth (today's daily-driver behaviour); every
- *    extension member walks its on-disk graph.
+ * 3. **Plan**: {@link planMigration} chooses `resolveRecordedPath` vs
+ *    `planFromDiff` per space according to `callerPolicy.ignoreGraphFor`.
+ *    The app space is forced through `planFromDiff` (today's daily-driver
+ *    behaviour); every extension space walks its on-disk graph via
+ *    `resolveRecordedPath`.
  * 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
@@ -168,9 +169,9 @@ export async function executeRun<TFamilyId extends string, TTargetId extends str
   });
   onProgress?.({ action, kind: 'spanEnd', spanId: SPAN_IDS.introspect, outcome: 'ok' });
 
-  // 3. Plan via aggregate planner. App is forced through synth (today's
-  // `db init` / `db update` daily-driver behaviour); extensions walk
-  // their on-disk migration graphs.
+  // 3. Plan via aggregate planner. App is forced through planFromDiff
+  // (today's `db init` / `db update` daily-driver behaviour); extensions
+  // walk their on-disk migration graphs via resolveRecordedPath.
   onProgress?.({
     action,
     kind: 'spanStart',
@@ -200,7 +201,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;
@@ -228,9 +229,9 @@ export async function executeRun<TFamilyId extends string, TTargetId extends str
   // 5. Run mode: hand off to the shared `runMigration` primitive.
   // The runner-driving tail is identical for `db init` / `db update` /
   // `migrate` — only how each caller produces `perSpacePlans`
-  // differs (synth + graph-walk via planMigration here; graph-walk
-  // only for migrate). Each caller produces perSpacePlans differently;
-  // this helper handles the shared run tail.
+  // differs (planFromDiff + resolveRecordedPath via planMigration here;
+  // resolveRecordedPath only for migrate). Each caller produces
+  // perSpacePlans differently; this helper handles the shared run tail.
   const applied = await runMigration({
     aggregate,
     perSpacePlans: planResult.value.perSpace,
@@ -280,14 +281,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 +297,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);
     }
   }
@@ -328,7 +329,7 @@ function detectOrphanMarkers(
 }
 
 function mapPlannerError(error: PlannerError): DbInitResult | DbUpdateResult {
-  if (error.kind === 'appSynthFailure') {
+  if (error.kind === 'planFromDiffFailed') {
     const failure: DbInitFailure | DbUpdateFailure = {
       code: 'PLANNING_FAILED',
       summary: 'Migration planning failed due to conflicts',

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

@@ -4,16 +4,19 @@ import type {
   ControlDriverInstance,
   ControlExtensionDescriptor,
   ControlFamilyInstance,
+  SchemaDiffIssue,
   VerifyDatabaseSchemaResult,
 } from '@prisma-next/framework-components/control';
+import { hasSchemaSubjectClassifier } 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 { ifDefined } from '@prisma-next/utils/defined';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 import { CliStructuredError } from '../../utils/cli-errors';
 import {
@@ -37,9 +40,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 +66,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 +94,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>,
@@ -109,13 +118,26 @@ export async function executeDbVerify<TFamilyId extends string, TTargetId extend
         contract: collectAggregateNamespaces(aggregate),
       });
 
+  // The subject-granularity + entity-kind classifiers are an injected
+  // capability — not every family provides one — detected the same way the
+  // other optional per-family capabilities are (`hasSchemaView`, …), never
+  // assumed.
+  const classifySubjectGranularity = hasSchemaSubjectClassifier(familyInstance)
+    ? (issue: SchemaDiffIssue) => familyInstance.classifySubjectGranularity(issue)
+    : undefined;
+  const classifyEntityKind = hasSchemaSubjectClassifier(familyInstance)
+    ? (issue: SchemaDiffIssue) => familyInstance.classifyEntityKind(issue)
+    : undefined;
+
   emitVerifySpan(onProgress, 'spanStart');
   const verifyResult = verifyMigration({
     aggregate,
     markersBySpaceId,
     schemaIntrospection,
     mode: options.mode,
-    verifySchemaForMember: createPerMemberVerifier(options),
+    verifySchemaForSpace: createPerSpaceVerifier(options),
+    ...ifDefined('classifySubjectGranularity', classifySubjectGranularity),
+    ...ifDefined('classifyEntityKind', classifyEntityKind),
   });
   return finaliseVerifyResult({ verifyResult, aggregate, skipMarker, onProgress });
 }
@@ -166,30 +188,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 +242,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 +272,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,
@@ -272,18 +292,6 @@ function buildSkippedSchemaResult(member: ContractSpaceMember): VerifyDatabaseSc
     target: { expected: contract.target },
     schema: {
       issues: [],
-      root: {
-        status: 'pass',
-        kind: 'skipped',
-        name: member.spaceId,
-        contractPath: '',
-        code: 'SKIPPED',
-        message: 'Schema verification skipped',
-        expected: undefined,
-        actual: undefined,
-        children: [],
-      },
-      counts: { pass: 0, warn: 0, fail: 0, totalNodes: 0 },
     },
     timings: { total: 0 },
   };

package/src/control-api/operations/migrate.ts

@@ -1,5 +1,5 @@
 /**
- * Backs the `migrate` command. Strategy: graph-walk-all-members, replay-only (no introspect/synth/planner).
+ * Backs the `migrate` command. Resolves the recorded path for every space, replay-only (no introspect/diff/planner).
  */
 
 import type { Contract } from '@prisma-next/contract/types';
@@ -11,13 +11,13 @@ import type {
   TargetMigrationsCapability,
 } from '@prisma-next/framework-components/control';
 import {
-  buildSynthMigrationEdge,
+  type AggregateContractSpace,
+  buildFabricatedMigrationEdge,
   type ContractMarkerRecordLike,
   type ContractSpaceAggregate,
-  type ContractSpaceMember,
-  graphWalkStrategy,
   type PerSpacePlan,
   requireHeadRef,
+  resolveRecordedPath,
 } from '@prisma-next/migration-tools/aggregate';
 import { EMPTY_CONTRACT_HASH } from '@prisma-next/migration-tools/constants';
 import { errorNoInvariantPath } from '@prisma-next/migration-tools/errors';
@@ -62,8 +62,8 @@ export interface ExecuteMigrateOptions<TFamilyId extends string, TTargetId exten
   readonly extensionPacks: ReadonlyArray<ControlExtensionDescriptor<TFamilyId, TTargetId>>;
   readonly targetId: TTargetId;
   /**
-   * Optional app-space ref override. When provided, the app member's
-   * graph-walk targets this hash instead of `member.headRef.hash`.
+   * Optional app-space ref override. When provided, the app space's
+   * graph-walk targets this hash instead of `space.headRef.hash`.
    * Extensions are unaffected — they always walk to their own head.
    */
   readonly refHash?: string;
@@ -72,7 +72,7 @@ export interface ExecuteMigrateOptions<TFamilyId extends string, TTargetId exten
    * Threaded into the graph-walk's `required` calculation so the
    * planner picks an invariant-bearing path and surfaces the
    * required/satisfied set on the success envelope. When `refHash`
-   * is absent the file's `member.headRef.invariants` are used.
+   * is absent the file's `space.headRef.invariants` are used.
    */
   readonly refInvariants?: readonly string[];
   /**
@@ -89,16 +89,16 @@ export interface ExecuteMigrateOptions<TFamilyId extends string, TTargetId exten
 /**
  * Apply pending migrations across every contract space (app +
  * extensions). Replay-only: graph-walk against the on-disk graph for
- * every member; no synth, no introspection.
+ * every contract space; no synth, no introspection.
  *
  * Pipeline:
  *
  * 1. Load aggregate from disk (loader hydrates extension graphs;
  *    caller provides app-space packages).
  * 2. Read live marker rows per space (`familyInstance.readAllMarkers`).
- * 3. Per member: `graphWalkStrategy` plots the path from the live
- *    marker to `member.headRef.hash` (or `refHash` for the app
- *    member when provided). Empty-graph members fail loudly — a
+ * 3. Per space: `resolveRecordedPath` plots the path from the live
+ *    marker to `space.headRef.hash` (or `refHash` for the app
+ *    space when provided). Empty-graph spaces fail loudly — a
  *    "never planned" space is a user-error condition for replay.
  * 4. Hand off to {@link runMigration} (the runner-driving tail
  *    shared with `db init` / `db update`). Marker advancement is
@@ -140,41 +140,41 @@ export async function executeMigrate<TFamilyId extends string, TTargetId extends
 
   const markerRows = await familyInstance.readAllMarkers({ driver });
 
-  // Plan every member via graph-walk. App member targets `refHash`
+  // Plan every space via graph-walk. App space targets `refHash`
   // when provided, otherwise its own head; extensions always walk
   // to their own head ref.
-  const allMembers: ReadonlyArray<ContractSpaceMember> = [aggregate.app, ...aggregate.extensions];
+  const allSpaces: ReadonlyArray<AggregateContractSpace> = [aggregate.app, ...aggregate.extensions];
   const perSpacePlans = new Map<string, PerSpacePlan>();
-  // Already-at-head empty-graph members (typically extensions whose
+  // Already-at-head empty-graph spaces (typically extensions whose
   // head ref is the empty sentinel, or whose live marker already
   // matches the target). Kept out of the runner schedule so we don't
   // write spurious markers for greenfield extensions, but merged back
-  // into the success envelope so every loaded member is represented.
+  // into the success envelope so every loaded space is represented.
   const atHeadResolutions = new Map<string, PerSpacePlan>();
-  for (const member of allMembers) {
-    const isAppMember = member.spaceId === aggregate.app.spaceId;
-    // The aggregate passed the integrity gate, so every member's head ref
+  for (const space of allSpaces) {
+    const isAppSpace = space.spaceId === aggregate.app.spaceId;
+    // The aggregate passed the integrity gate, so every space's head ref
     // is resolved (the app's is synthesised from the live contract).
-    const headRef = requireHeadRef(member);
-    const memberTargetHash = isAppMember && refHash !== undefined ? refHash : headRef.hash;
-    const memberRefInvariants = isAppMember && refHash !== undefined ? refInvariants : undefined;
-    const liveMarker = markerRows.get(member.spaceId) ?? null;
+    const headRef = requireHeadRef(space);
+    const spaceTargetHash = isAppSpace && refHash !== undefined ? refHash : headRef.hash;
+    const spaceRefInvariants = isAppSpace && refHash !== undefined ? refInvariants : undefined;
+    const liveMarker = markerRows.get(space.spaceId) ?? null;
 
-    const outcome = planMemberPath({
-      member,
+    const outcome = planSpacePath({
+      space,
       aggregate,
-      targetHash: memberTargetHash,
-      refInvariants: memberRefInvariants,
+      targetHash: spaceTargetHash,
+      refInvariants: spaceRefInvariants,
       liveMarker,
-      ...(isAppMember ? { refName } : {}),
+      ...(isAppSpace ? { refName } : {}),
     });
 
     if (outcome.kind === 'at-head') {
-      // Empty-graph member whose live marker already matches the target.
+      // Empty-graph space whose live marker already matches the target.
       // Kept out of the runner schedule so we don't write spurious markers
       // for greenfield extensions, but merged back into the success envelope
-      // so every loaded member is represented.
-      atHeadResolutions.set(member.spaceId, outcome.plan);
+      // so every loaded space is represented.
+      atHeadResolutions.set(space.spaceId, outcome.plan);
       continue;
     }
     if (outcome.kind === 'never-planned') {
@@ -197,9 +197,9 @@ export async function executeMigrate<TFamilyId extends string, TTargetId extends
       // is never a graph node, producing an empty `structuralPath` and
       // a less actionable diagnostic.
       const structural = findPathWithDecision(
-        outcome.targetMember.graph(),
+        outcome.targetSpace.graph(),
         outcome.liveHash,
-        memberTargetHash,
+        spaceTargetHash,
         { required: new Set<string>() },
       );
       const structuralPath =
@@ -220,14 +220,14 @@ export async function executeMigrate<TFamilyId extends string, TTargetId extends
       });
     }
 
-    perSpacePlans.set(member.spaceId, outcome.plan);
+    perSpacePlans.set(space.spaceId, outcome.plan);
   }
 
   const canonicalOrder = [...aggregate.extensions.map((m) => m.spaceId), aggregate.app.spaceId];
   const applyOrder = canonicalOrder.filter((spaceId) => perSpacePlans.has(spaceId));
 
   // Short-circuit: nothing pending across any space (no runner-bound
-  // plans). Surfaces every loaded member — including at-head empty-
+  // plans). Surfaces every loaded space — including at-head empty-
   // graph extensions — in `perSpace[]` so the result reflects the
   // full aggregate, not just the spaces the runner would have touched.
   const totalPlannedOps = sumPlannedOps(applyOrder, perSpacePlans);
@@ -285,7 +285,7 @@ export async function executeMigrate<TFamilyId extends string, TTargetId extends
   }
 
   // Merge at-head zero-op resolutions back into the canonical order
-  // so the success envelope surfaces every loaded member, not just
+  // so the success envelope surfaces every loaded space, not just
   // those the runner executed.
   const orderedAll = canonicalOrder
     .filter((spaceId) => perSpacePlans.has(spaceId) || atHeadResolutions.has(spaceId))
@@ -321,16 +321,16 @@ export async function executeMigrate<TFamilyId extends string, TTargetId extends
 }
 
 /**
- * Outcome variants for one member's path computation.
+ * Outcome variants for one space's path computation.
  *
  * Callers switch on `kind` and map to their own error representation:
  * `executeMigrate` throws / returns `notOk`; `executeMigrateShowCommand`
  * returns a CLI structured error. The shared discriminant guarantees both
- * paths feed `graphWalkStrategy` the same inputs.
+ * paths feed `resolveRecordedPath` the same inputs.
  *
  * @internal Exported for `executeMigrateShowCommand` to call.
  */
-export type MemberPathOutcome =
+export type SpacePathOutcome =
   | { readonly kind: 'ok'; readonly plan: PerSpacePlan }
   | { readonly kind: 'at-head'; readonly plan: PerSpacePlan }
   | { readonly kind: 'never-planned'; readonly spaceId: string; readonly targetHash: string }
@@ -343,16 +343,16 @@ export type MemberPathOutcome =
   | {
       readonly kind: 'unsatisfiable';
       readonly spaceId: string;
-      readonly isAppMember: boolean;
+      readonly isAppSpace: boolean;
       readonly missing: readonly string[];
       readonly targetInvariants: readonly string[];
-      readonly targetMember: ContractSpaceMember;
+      readonly targetSpace: AggregateContractSpace;
       readonly liveHash: string;
       readonly refName: string | undefined;
     };
 
 /**
- * Compute the graph-walk path for one contract-space member.
+ * Compute the graph-walk path for one contract space.
  *
  * Encapsulates the invariant-correct input assembly that both
  * `executeMigrate` and `executeMigrateShowCommand` must use:
@@ -361,71 +361,71 @@ export type MemberPathOutcome =
  * - `targetInvariants` uses the caller-supplied `refInvariants` when a
  *   `--to` ref was resolved (not always the file head ref's invariants).
  *
- * Both callers map the returned `MemberPathOutcome` to their own error
+ * Both callers map the returned `SpacePathOutcome` to their own error
  * representation; the path-compute logic is shared and identical.
  *
  * @internal Exported for `executeMigrateShowCommand`.
  */
-export function planMemberPath({
-  member,
+export function planSpacePath({
+  space,
   aggregate,
   targetHash,
   refInvariants,
   liveMarker,
   refName,
 }: {
-  readonly member: ContractSpaceMember;
+  readonly space: AggregateContractSpace;
   readonly aggregate: Pick<ContractSpaceAggregate, 'targetId' | 'app'>;
   readonly targetHash: string;
   readonly refInvariants: readonly string[] | undefined;
   readonly liveMarker: ContractMarkerRecordLike | null;
   readonly refName?: string;
-}): MemberPathOutcome {
-  const isAppMember = member.spaceId === aggregate.app.spaceId;
-  const headRef = requireHeadRef(member);
+}): SpacePathOutcome {
+  const isAppSpace = space.spaceId === aggregate.app.spaceId;
+  const headRef = requireHeadRef(space);
 
-  if (member.graph().nodes.size === 0) {
+  if (space.graph().nodes.size === 0) {
     const liveHash = liveMarker?.storageHash;
     if (targetHash === liveHash || (liveHash === undefined && targetHash === EMPTY_CONTRACT_HASH)) {
       return {
         kind: 'at-head',
         plan: buildAtHeadResolution({
           aggregateTargetId: aggregate.targetId,
-          member,
+          space,
           targetHash,
           liveMarker,
         }),
       };
     }
-    return { kind: 'never-planned', spaceId: member.spaceId, targetHash };
+    return { kind: 'never-planned', spaceId: space.spaceId, targetHash };
   }
 
   const targetInvariants =
-    isAppMember && refInvariants !== undefined ? refInvariants : headRef.invariants;
-  const targetMember: ContractSpaceMember =
+    isAppSpace && refInvariants !== undefined ? refInvariants : headRef.invariants;
+  const targetSpace: AggregateContractSpace =
     targetHash === headRef.hash && targetInvariants === headRef.invariants
-      ? member
-      : { ...member, headRef: { hash: targetHash, invariants: targetInvariants } };
+      ? space
+      : { ...space, headRef: { hash: targetHash, invariants: targetInvariants } };
 
-  const walked = graphWalkStrategy({
+  const walked = resolveRecordedPath({
     aggregateTargetId: aggregate.targetId,
-    member: targetMember,
+    space: targetSpace,
     currentMarker: liveMarker,
-    ...(isAppMember && refName !== undefined ? { refName } : {}),
+    ...(isAppSpace && refName !== undefined ? { refName } : {}),
   });
 
   if (walked.kind === 'unreachable') {
-    return { kind: 'unreachable', spaceId: member.spaceId, liveMarker, targetHash };
+    return { kind: 'unreachable', spaceId: space.spaceId, liveMarker, targetHash };
   }
   if (walked.kind === 'unsatisfiable') {
     const liveHash = liveMarker?.storageHash ?? EMPTY_CONTRACT_HASH;
     return {
       kind: 'unsatisfiable',
-      spaceId: member.spaceId,
-      isAppMember,
+      spaceId: space.spaceId,
+      isAppSpace,
       missing: walked.missing,
       targetInvariants,
-      targetMember,
+      targetSpace,
       liveHash,
       refName,
     };
@@ -435,32 +435,32 @@ export function planMemberPath({
 
 /**
  * Build a zero-op {@link PerSpacePlan} for an empty-graph
- * member whose live marker already matches the target. Lets the apply
- * pipeline thread the member through `perSpacePlans` -> `applyOrder`
+ * space whose live marker already matches the target. Lets the apply
+ * pipeline thread the space through `perSpacePlans` -> `applyOrder`
  * -> the success envelope's `perSpace[]` block so the result reflects
  * every loaded space, even when there is nothing to execute.
  */
 function buildAtHeadResolution(args: {
   readonly aggregateTargetId: string;
-  readonly member: ContractSpaceMember;
+  readonly space: AggregateContractSpace;
   readonly targetHash: string;
   readonly liveMarker: ContractMarkerRecordLike | null;
 }): PerSpacePlan {
-  const { aggregateTargetId, member, targetHash, liveMarker } = args;
+  const { aggregateTargetId, space, targetHash, liveMarker } = args;
   return {
     plan: {
       targetId: aggregateTargetId,
-      spaceId: member.spaceId,
+      spaceId: space.spaceId,
       origin: liveMarker === null ? null : { storageHash: liveMarker.storageHash },
       destination: { storageHash: targetHash },
       operations: [],
       providedInvariants: [],
     },
     displayOps: [],
-    destinationContract: member.contract(),
-    strategy: 'graph-walk',
+    destinationContract: space.contract(),
+    strategy: 'declared-state',
     migrationEdges: [
-      buildSynthMigrationEdge({
+      buildFabricatedMigrationEdge({
         currentMarkerStorageHash: liveMarker?.storageHash,
         destinationStorageHash: targetHash,
         operationCount: 0,
@@ -494,7 +494,7 @@ interface BuildSuccessArgs {
 }
 
 function buildSuccess(args: BuildSuccessArgs): MigrateSuccess {
-  // The marker hash surfaced at the top level is the **app member's**
+  // The marker hash surfaced at the top level is the **app space's**
   // post-migrate marker (the top-level `markerHash` field).
   // Per-space markers live on `perSpace[].marker.storageHash`.
   const appResolution = args.orderedResolutions.find(
@@ -586,7 +586,7 @@ export function buildPathNotFoundFailure(
   const fromHash = marker?.storageHash ?? '<empty>';
   // The app-case phrasing names the user-visible condition (a
   // contract has been emitted that no on-disk migration reaches) so
-  // the error reads naturally for the app member. Extension spaces
+  // the error reads naturally for the app space. Extension spaces
   // see the same condition expressed against the offending space.
   const summary =
     spaceId === 'app'