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

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. Strategy: graph-walk-all-spaces, replay-only (no introspect/synth/planner).
  */
 
 import type { Contract } from '@prisma-next/contract/types';
@@ -11,10 +11,10 @@ import type {
   TargetMigrationsCapability,
 } from '@prisma-next/framework-components/control';
 import {
+  type AggregateContractSpace,
   buildSynthMigrationEdge,
   type ContractMarkerRecordLike,
   type ContractSpaceAggregate,
-  type ContractSpaceMember,
   graphWalkStrategy,
   type PerSpacePlan,
   requireHeadRef,
@@ -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: `graphWalkStrategy` 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,7 +321,7 @@ 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`
@@ -330,7 +330,7 @@ export async function executeMigrate<TFamilyId extends string, TTargetId extends
  *
  * @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({
     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,29 +435,29 @@ 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(),
+    destinationContract: space.contract(),
     strategy: 'graph-walk',
     migrationEdges: [
       buildSynthMigrationEdge({
@@ -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'

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

@@ -48,7 +48,7 @@ export interface RunMigrationInputs<TFamilyId extends string, TTargetId extends
    * {@link planMigration} pipeline (`db init` / `db update` — synth
    * for the app, graph-walk for extensions) or by direct
    * {@link graphWalkStrategy} calls (`migrate` — graph-walk
-   * for every member). Either way, the runner consumes the same shape.
+   * for every contract space). Either way, the runner consumes the same shape.
    */
   readonly perSpacePlans: ReadonlyMap<string, PerSpacePlan>;
   /**
@@ -229,7 +229,7 @@ export function buildPerSpaceBreakdown(
 
 /**
  * Materialise the `applyOrder` ordering into resolved per-space
- * entries. Throws if the planner output is missing a member listed
+ * entries. Throws if the planner output is missing a contract space listed
  * in `applyOrder` — a wiring bug that should never reach runtime.
  *
  * Exported so callers building their own success envelopes after a

package/src/control-api/types.ts

@@ -557,9 +557,9 @@ export interface MigrateOptions {
   /** Migrations root directory (`migrations/` under the project). */
   readonly migrationsDir: string;
   /**
-   * Optional app-space ref override. When provided, the app member's
+   * Optional app-space ref override. When provided, the app space's
    * graph-walk targets this hash instead of `contract.storage.storageHash`.
-   * Extension members always walk to their own `headRef.hash`.
+   * Extension spaces always walk to their own `headRef.hash`.
    */
   readonly refHash?: string;
   /**
@@ -631,17 +631,17 @@ export interface MigrateRanEntry {
 
 /**
  * Successful migrate result. Carries both the top-level fields
- * (`markerHash` is the **app member's** post-migrate marker) and the
+ * (`markerHash` is the **app space's** post-migrate marker) and the
  * per-space breakdown (`perSpace` — markers / operations in canonical
  * schedule order).
  */
 /**
- * Path-decision summary for the **app member** post-migrate. Surfaced
+ * Path-decision summary for the **app space** post-migrate. Surfaced
  * at the top level (and consumed by the cli-journeys suite, which
  * inspects `requiredInvariants`/`satisfiedInvariants`/
  * `selectedPath` to validate invariant routing).
  *
- * Per-space path decisions for extension members are not surfaced —
+ * Per-space path decisions for extension spaces are not surfaced —
  * extensions own their own ref/invariant control.
  */
 export interface MigratePathDecision {
@@ -673,7 +673,7 @@ export interface MigrateSuccess {
    */
   readonly perSpace: ReadonlyArray<PerSpaceExecutionEntry>;
   /**
-   * Path-decision data for the app member. Present whenever the
+   * Path-decision data for the app space. Present whenever the
    * graph-walk strategy ran for the app (i.e. always for the
    * aggregate-walking migrate path). Absent only for the no-op
    * "Already up to date" early return when the app has no plan.
@@ -864,7 +864,7 @@ export interface ControlClient {
    *   markers, and (unless `skipSchema` is true) per-space schema
    *   verification with pre-projection (closes F23).
    *
-   * @returns Result pattern: per-space schema results on success;
+   * @returns Result pattern: per-space verify results on success;
    *          structured CLI error on marker / loader failure.
    * @throws If not connected or infrastructure failure
    */

package/src/utils/combine-verify-results.ts

@@ -0,0 +1,113 @@
+import type { VerifyDatabaseSchemaResult } from '@prisma-next/framework-components/control';
+
+/**
+ * The combined per-space contract-satisfaction result plus the standalone
+ * unclaimed-elements list, reported once. The CLI renders
+ * both; `unclaimed` is never folded into the combined tree or its issues.
+ */
+export interface CombinedVerifyResult {
+  readonly result: VerifyDatabaseSchemaResult;
+  readonly unclaimed: readonly string[];
+}
+
+/**
+ * Collapse the aggregate verifier's per-space contract-satisfaction results
+ * into a single {@link VerifyDatabaseSchemaResult} for the existing CLI
+ * display surface, and carry the deduplicated unclaimed-elements list
+ * alongside it. Concatenates issues across spaces; sums counts; uses the app
+ * space's result as the structural envelope (storage hash, target). Extras are
+ * already stripped from each per-space result, so nothing here duplicates an
+ * unclaimed element per space.
+ *
+ * **Unclaimed disposition.** In strict mode a non-empty `unclaimed` list fails
+ * the combined verdict (`ok: false`); in lenient mode it is carried for
+ * informational rendering only. The list itself is returned unchanged for the
+ * renderer.
+ *
+ * **Summary policy.** Preserve the per-family phrasing whenever the
+ * combined `ok` flag agrees with the app space's `ok` flag — this is
+ * the common case (single-family deployments, single-app deployments)
+ * and the family's "satisfies / does not satisfy contract" phrasing
+ * stays user-visible. When the app passes but an extension fails (or
+ * vice versa) the app's summary contradicts the envelope, so fall back
+ * to the first failing space's summary. This keeps family phrasing
+ * intact and the envelope internally consistent (`ok: false` ↔ failure
+ * summary).
+ */
+export function combineVerifyResults(
+  perSpace: ReadonlyMap<string, VerifyDatabaseSchemaResult>,
+  appSpaceId: string,
+  strict: boolean,
+  unclaimed: readonly string[],
+): CombinedVerifyResult {
+  const appResult = perSpace.get(appSpaceId) ?? perSpace.values().next().value;
+  if (appResult === undefined) {
+    throw new Error(
+      'Aggregate verifier returned no per-space verify results — this is a wiring bug.',
+    );
+  }
+
+  let okAll = true;
+  let firstFailure: VerifyDatabaseSchemaResult | undefined;
+  let issues: VerifyDatabaseSchemaResult['schema']['issues'] = [];
+  let schemaDiffIssues: VerifyDatabaseSchemaResult['schema']['schemaDiffIssues'] = [];
+  const counts = { pass: 0, warn: 0, fail: 0, totalNodes: 0 };
+  const childRoots: Array<VerifyDatabaseSchemaResult['schema']['root']> = [];
+  for (const [, result] of perSpace) {
+    if (!result.ok) {
+      okAll = false;
+      if (firstFailure === undefined) firstFailure = result;
+    }
+    issues = [...issues, ...result.schema.issues];
+    schemaDiffIssues = [...schemaDiffIssues, ...result.schema.schemaDiffIssues];
+    counts.pass += result.schema.counts.pass;
+    counts.warn += result.schema.counts.warn;
+    counts.fail += result.schema.counts.fail;
+    counts.totalNodes += result.schema.counts.totalNodes;
+    childRoots.push(result.schema.root);
+  }
+
+  const unclaimedFails = strict && unclaimed.length > 0;
+  const ok = okAll && !unclaimedFails;
+
+  // Prefer a failing space's family phrasing; else, when only the unclaimed list
+  // fails the verdict, say so; else keep the app space's phrasing. When `okAll`
+  // is false the loop assigned `firstFailure`, so the `?? appResult.summary`
+  // fallback is unreachable — it exists only to keep the read cast-free.
+  const summary = okAll
+    ? unclaimedFails
+      ? `Database schema has ${unclaimed.length} unclaimed element${unclaimed.length === 1 ? '' : 's'} (not in any contract)`
+      : appResult.summary
+    : appResult.ok
+      ? (firstFailure?.summary ?? appResult.summary)
+      : appResult.summary;
+
+  return {
+    result: {
+      ok,
+      ...(ok ? {} : { code: appResult.code ?? 'PN-RUN-3010' }),
+      summary,
+      contract: appResult.contract,
+      target: appResult.target,
+      schema: {
+        issues,
+        schemaDiffIssues,
+        root: {
+          status: ok ? 'pass' : 'fail',
+          kind: 'aggregate',
+          name: 'aggregate',
+          contractPath: '',
+          code: 'AGGREGATE',
+          message: ok ? 'Aggregate schema matches' : 'Aggregate schema mismatch',
+          expected: undefined,
+          actual: undefined,
+          children: childRoots,
+        },
+        counts,
+      },
+      meta: { strict },
+      timings: { total: 0 },
+    },
+    unclaimed,
+  };
+}

package/src/utils/extension-pack-inputs.ts

@@ -111,7 +111,7 @@ export function toExtensionInputs(
  * {@link import('./contract-space-aggregate-loader').buildContractSpaceAggregate}.
  *
  * Codec-only extensions (no `contractSpace` declaration) are filtered
- * out: they are not contract-space members, so the aggregate loader
+ * out: they contribute no contract space, so the aggregate loader
  * has nothing to do with them. Filtering happens at this descriptor-
  * import boundary so the loader stays oblivious to that distinction —
  * every entry it sees expects an on-disk `migrations/<id>/` directory.

package/src/utils/formatters/verify.ts

@@ -30,6 +30,12 @@ export interface DbVerifyCommandSuccessResult {
     readonly counts: VerifyDatabaseSchemaResult['schema']['counts'];
     readonly strict: boolean;
   };
+  /**
+   * Live element names no contract space declares. In full success this is
+   * only ever non-empty in lenient mode — strict mode fails on it — and is
+   * rendered informationally.
+   */
+  readonly unclaimed?: readonly string[];
   readonly warning?: string;
   readonly meta?:
     | (NonNullable<VerifyDatabaseResult['meta']> & {
@@ -76,6 +82,14 @@ export function formatVerifyOutput(
       `${formatDimText(`  schema: pass=${result.schema.counts.pass} warn=${result.schema.counts.warn} fail=${result.schema.counts.fail}`)}`,
     );
   }
+  if (result.unclaimed && result.unclaimed.length > 0) {
+    lines.push('');
+    lines.push(formatYellow('Unclaimed elements (declared by no contract):'));
+    for (const name of result.unclaimed) {
+      lines.push(`  ${formatYellow('⚠')} ${name}`);
+    }
+  }
+
   if (result.warning) {
     lines.push('');
     lines.push(`${formatYellow('⚠')} ${result.warning}`);
@@ -107,6 +121,7 @@ export function formatVerifyJson(result: DbVerifyCommandSuccessResult): string {
     ...ifDefined('missingCodecs', result.missingCodecs),
     ...ifDefined('codecCoverageSkipped', result.codecCoverageSkipped),
     ...ifDefined('schema', result.schema),
+    unclaimed: result.unclaimed ?? [],
     ...ifDefined('warning', result.warning),
     ...ifDefined('meta', result.meta),
     timings: result.timings,
@@ -517,6 +532,7 @@ function renderSchemaVerificationTree(
 export function formatSchemaVerifyOutput(
   result: VerifyDatabaseSchemaResult,
   flags: GlobalFlags,
+  unclaimed: readonly string[] = [],
 ): string {
   if (flags.quiet) {
     return '';
@@ -527,6 +543,7 @@ export function formatSchemaVerifyOutput(
   const useColor = flags.color !== false;
   const formatGreen = createColorFormatter(useColor, green);
   const formatRed = createColorFormatter(useColor, red);
+  const formatYellow = createColorFormatter(useColor, yellow);
   const formatDimText = (text: string) => formatDim(useColor, text);
 
   // Render verification tree first
@@ -547,6 +564,17 @@ export function formatSchemaVerifyOutput(
     }
   }
 
+  if (unclaimed.length > 0) {
+    const strict = result.meta?.strict ?? false;
+    lines.push('');
+    lines.push(
+      (strict ? formatRed : formatYellow)('Unclaimed elements (declared by no contract):'),
+    );
+    for (const name of unclaimed) {
+      lines.push(`  ${(strict ? formatRed : formatYellow)(strict ? '✖' : '⚠')} ${name}`);
+    }
+  }
+
   // Add counts and timings in verbose mode
   if (isVerbose(flags, 1)) {
     lines.push(`${formatDimText(`  Total time: ${result.timings.total}ms`)}`);
@@ -570,10 +598,15 @@ export function formatSchemaVerifyOutput(
 }
 
 /**
- * Formats JSON output for database schema verification.
+ * Formats JSON output for database schema verification. The unclaimed-elements
+ * list is a top-level field alongside the combined result, reported once for
+ * the whole database.
  */
-export function formatSchemaVerifyJson(result: VerifyDatabaseSchemaResult): string {
-  return JSON.stringify(result, null, 2);
+export function formatSchemaVerifyJson(
+  result: VerifyDatabaseSchemaResult,
+  unclaimed: readonly string[] = [],
+): string {
+  return JSON.stringify({ ...result, unclaimed }, null, 2);
 }
 
 // ============================================================================