TML-3008: differ pairs siblings by (nodeKind, id) — delete the role-sigil workaround (#952)

## Linked issue

Refs
[TML-3008](https://linear.app/prisma-company/issue/TML-3008/schema-differ-pairs-siblings-by-nodekind-id-delete-the-role-sigil)

Unblocks [#950](#950)
(TML-2870), which rebases onto this and deletes its `role:`-sigil
workaround.

## At a glance

```ts
// packages/1-framework/1-core/framework-components/src/control/schema-diff.ts
export interface DiffableNode {
  readonly id: string;
  readonly nodeKind: string;
  isEqualTo(other: DiffableNode): boolean;
  children(): readonly DiffableNode[];
}
```

Before this PR the differ keyed a parent's children into one flat map on
bare `id` and threw `diffSchemas: duplicate id among siblings` on any
collision — so a Postgres role named `public` and a schema named
`public`, which are different objects that never pair against each
other, could not coexist as siblings in the diff tree.

## Decision

Two things:

1. **The differ pairs siblings by `(nodeKind, id)`, not by a
globally-unique `id`.** `DiffableNode` gains `readonly nodeKind: string`
— the per-node discriminant every SQL schema-IR node already declares,
so the SQL tree satisfies it with zero changes. An `id` now only needs
to be unique among same-kind siblings, which it already is by
construction (you can't declare two roles named `public`, or two columns
named `id` on one table). A node never folds its kind into its id string
to route around the differ.
2. **`SchemaDiffIssue.message` is deleted.** The differ reports
structured data (`path`, `reason`, the nodes); turning that into a human
sentence is the renderer's job. Every producer that baked prose into
`message` — including Mongo's hand-rolled `diffMongoSchemas` — stops;
every consumer renders from `path`/`reason` itself.

## Reviewer notes

- **Byte-identity is the review question.** Sibling pairing uses a
single `Map` keyed on `` `${nodeKind}\u0000${id}` `` — deliberately
*not* a nested per-kind map — so insertion order, and therefore
emitted-issue order, is bit-for-bit what it was. Every `nodeKind` in the
repo is a code-defined literal, so the NUL delimiter cannot collide. The
only input whose behavior changes is one that previously **threw**
(cross-kind sibling id collision); no previously-succeeding diff changes
output. Zero fixture/snapshot/golden files changed in this PR.
- **Mongo `db verify` failure text becomes path-based.**
`diffMongoSchemas` used to bake sentences like `Collection "users" is
missing from the database` into `message`; issues now render as `users`
/ `orders/validator` with the `reason` label. Accepted deliberately — no
committed snapshot pinned the prose, and a follow-up renderer can
rebuild richer text from the structured issue when wanted.
- **The `message` sweep is most of the diff.** The keying change itself
is ~40 lines; the other ~30 files are consumers and test literals that
carried `message`. One consumer was missed on the first pass and caught
by review: the CLI error-envelope formatter printed blank issue bodies
for SQLite/Mongo verify failures
([errors.ts](packages/1-framework/3-tooling/cli/src/utils/formatters/errors.ts)
now renders `message ?? path.join('/')`, since PSL diagnostics share
that envelope and legitimately carry `message`).
- **Slice process artifacts**
(`projects/postgres-rls/slices/differ-kind-keying/`) are committed for
review context and are cleaned up at project close-out, per this repo's
Drive convention.

## How it fits together

1. **The interface carries the discriminant.** `DiffableNode.nodeKind`
is an opaque string — no target vocabulary enters the framework. SQL
nodes inherit it from `SqlSchemaIRNode`'s existing abstract `nodeKind`;
the five Mongo schema-IR nodes each gain a genuine per-node literal
(`collection`, `index`, `validator`, `collectionOptions`, `schema`)
matching their existing `kind` discriminators 1:1.
2. **The differ keys on the pair.** `insertNode`/`diffChildren` build
the sibling map on the combined key and throw only on a genuine
same-kind/same-id duplicate
([schema-diff.ts](packages/1-framework/1-core/framework-components/src/control/schema-diff.ts)).
3. **Issues drop the baked message.** `pathMessage` and
`SchemaDiffIssue.message` are deleted; consumers that need a string
build it from `path` — the CLI verify formatter, `db verify`, the
sqlite/postgres issue planners' conflict summaries, and the CLI
error-envelope formatter.
4. **The ADR records the model.**
[adr-schema-diff-over-structured-ir.md](projects/postgres-rls/specs/adr-schema-diff-over-structured-ir.md)
now states per-kind sibling-id uniqueness and explicitly rejects folding
a node's kind into its `id()` (the guidance that produced #950's sigil).

## Behavior changes & evidence

- Same-name, different-kind siblings diff instead of throwing; each
pairs only against its own-kind counterpart. Implementation:
[schema-diff.ts](packages/1-framework/1-core/framework-components/src/control/schema-diff.ts).
Evidence:
[schema-diff.test.ts](packages/1-framework/1-core/framework-components/test/schema-diff.test.ts)
(role-`public`/namespace-`public` pair independently; same-kind/same-id
still throws; issues carry no `message`).
- Mongo schema-IR nodes declare `nodeKind`; the Mongo diff algorithm is
otherwise unchanged apart from dropping `message`. Implementation:
[schema-node.ts](packages/2-mongo-family/3-tooling/mongo-schema-ir/src/schema-node.ts),
[schema-diff.ts](packages/2-mongo-family/9-family/src/core/schema-diff.ts).
Evidence:
[cli.control-policy.mongo.e2e.test.ts](test/integration/test/cli.control-policy.mongo.e2e.test.ts).
- CLI issue rendering is path-based where prose was removed, with PSL
diagnostics keeping their messages. Implementation:
[verify.ts](packages/1-framework/3-tooling/cli/src/utils/formatters/verify.ts),
[errors.ts](packages/1-framework/3-tooling/cli/src/utils/formatters/errors.ts).
Evidence:
[output.errors.test.ts](packages/1-framework/3-tooling/cli/test/output.errors.test.ts)
(pins both producer shapes).

## Testing performed

- `pnpm build` (68/68), forced `pnpm typecheck` (143/143), `pnpm lint` +
`pnpm lint:deps` on touched packages
- `pnpm test:packages` (12k+ tests), `pnpm test:integration`, `pnpm
test:e2e` (109/109)
- `pnpm fixtures:check` — clean; `git status` after: no
fixture/snapshot/golden file changed
- Reproduced-and-ruled-pre-existing flakes: config-loader `/var`
symlink, sql-orm-client portal race (both known families, untouched
files)

## Follow-ups

- PR #950 rebases onto this and deletes its `role:` sigil +
`withCleanRoleMessage` (TML-2870).
- Optional richer issue rendering (human sentences rebuilt from
structured issues in the CLI formatter) if path-based output proves too
terse.

## Alternatives considered

- **Fold the kind into the id string (the `role:` sigil).** Rejected —
it re-encodes lost structural information into a name, then leaks into
paths and needs laundering (`withCleanRoleMessage`). That workaround is
what #950 currently ships and deletes after this merges.
- **Key the differ on the contract `EntityCoordinate`.** Rejected (and
the ADR's original rejection stands) — schema-IR-node identity is its
own domain; mapping a schema-IR node to a contract coordinate is a
separate consumer-side operation, not the diff walk's concern.
- **A nested `Map<nodeKind, Map<id, node>>`.** Rejected — regrouping by
kind changes iteration order and would break emitted-issue
byte-identity; the single combined-key map preserves insertion order
exactly.
- **Keep `message` populated with the path string.** Rejected — it
duplicates `path` as a pre-rendered string and invites producers (as
Mongo did) to bake presentation into data the renderer should own.

## Checklist

- [x] All commits DCO-signed (`Signed-off-by`)
- [x] Tests written/updated for the behavior changes
- [x] Title follows `TML-XXXX: <sentence case>` convention
- [x] Docs/ADR updated where behavior is described


<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

* **Bug Fixes**
* Improved schema-diff matching to avoid conflating items that share an
ID but differ by node type.
* Schema verification and CLI/database-check output now consistently
identify issues using their structured paths (with reason), including in
warnings and formatted error output.
* Migration/rebuild summaries now use deterministic, path-based
locations for conflicts.

* **Refactor**
* Schema-diff issues no longer rely on a preformatted message; they use
structured fields such as path, reason, expected, and actual.
* Mongo schema IR nodes now expose `nodeKind` instead of `kind` for type
discrimination.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

---------

Signed-off-by: willbot <w.a.madden+machine@gmail.com>
Signed-off-by: Will Madden <madden@prisma.io>

Author: wmadden-electric

packages/1-framework/1-core/framework-components/src/control/schema-diff.ts

@@ -5,7 +5,6 @@ export interface SchemaDiffIssue<TNode extends DiffableNode = DiffableNode> {
   readonly path: readonly string[];
   /** Why the actual state fails the expectation. Consumers filter on this field. */
   readonly reason: ExpectationFailureReason;
-  readonly message: string;
   /** The expected (desired-side) node, when available. Absent for `not-expected` issues. */
   readonly expected?: TNode;
   /** The actual (current-side) node, when available. Absent for `not-found` issues. */
@@ -15,43 +14,45 @@ export interface SchemaDiffIssue<TNode extends DiffableNode = DiffableNode> {
 /**
  * A node in the schema tree. Every node in the tree implements this interface.
  *
- * `id` must be unique among sibling nodes at the same level — the differ keys
- * on it and treats a collision as the same entity (enforced by a duplicate-id
- * throw). The differ accumulates these ids into a path that stamps every emitted
- * issue.
+ * The differ pairs siblings by the combination of `nodeKind` and `id`, not by
+ * `id` alone: `id` needs only be unique among siblings of the same
+ * `nodeKind` at the same level, not globally unique at that level. Two
+ * distinct kinds of child in distinct slots (e.g. a role and a namespace) may
+ * legitimately share a name — they are never paired against each other, so
+ * the collision is harmless. A node never folds its kind into its id string
+ * to route around this; `nodeKind` is the discriminant that does that job.
+ * A same-`nodeKind`/same-`id` collision among siblings is a genuine
+ * duplicate and is enforced by a throw. The differ accumulates ids (not
+ * nodeKind) into a path that stamps every emitted issue.
  */
 export interface DiffableNode {
   readonly id: string;
+  readonly nodeKind: string;
   isEqualTo(other: DiffableNode): boolean;
   children(): readonly DiffableNode[];
 }
 
+/** Delimiter joining `nodeKind` and `id` into one sibling-map key. Every `nodeKind` is a code-defined literal (kebab-case-style), so a null character can never appear in one. */
+const SIBLING_KEY_DELIMITER = '\u0000';
+
+function siblingKey(node: DiffableNode): string {
+  return `${node.nodeKind}${SIBLING_KEY_DELIMITER}${node.id}`;
+}
+
 function insertNode(map: Map<string, DiffableNode>, node: DiffableNode): void {
-  const key = node.id;
+  const key = siblingKey(node);
   if (map.has(key)) {
-    throw new Error(`diffSchemas: duplicate id among siblings: ${key}`);
+    throw new Error(`diffSchemas: duplicate id among siblings: ${node.nodeKind}/${node.id}`);
   }
   map.set(key, node);
 }
 
-/**
- * The issue's own default message: the path, nothing else. `reason` already
- * carries why the node is flagged as structured data; turning that into a
- * human label ("missing: …" / "extra: …" / "mismatch: …") is a presentation
- * concern for whoever renders the issue (the CLI verify formatter), not the
- * differ's.
- */
-function pathMessage(path: readonly string[]): string {
-  return path.join('/');
-}
-
 function emitMissingSubtree(node: DiffableNode, parentPath: readonly string[]): SchemaDiffIssue[] {
   const path = [...parentPath, node.id];
   return [
     {
       path,
       reason: 'not-found',
-      message: pathMessage(path),
       expected: node,
     },
     ...node.children().flatMap((c) => emitMissingSubtree(c, path)),
@@ -64,7 +65,6 @@ function emitExtraSubtree(node: DiffableNode, parentPath: readonly string[]): Sc
     {
       path,
       reason: 'not-expected',
-      message: pathMessage(path),
       actual: node,
     },
     ...node.children().flatMap((c) => emitExtraSubtree(c, path)),
@@ -98,7 +98,6 @@ function diffPair(
     issues.push({
       path,
       reason: 'not-equal',
-      message: pathMessage(path),
       expected,
       actual,
     });
@@ -108,7 +107,8 @@ function diffPair(
 }
 
 /**
- * Align one level of nodes by id; emit issues in input order and recurse.
+ * Align one level of nodes by `(nodeKind, id)`; emit issues in input order
+ * and recurse.
  *
  * A missing node emits one issue for itself and one for every node in its
  * subtree (total descent). Same for extra nodes. A matched pair recurses via

packages/1-framework/1-core/framework-components/test/schema-diff.test.ts

@@ -6,6 +6,7 @@ import { diffSchemas, SchemaDiff } from '../src/control/schema-diff';
 function rootOf(nodes: readonly DiffableNode[]): DiffableNode {
   return {
     id: 'root',
+    nodeKind: 'root',
     isEqualTo(): boolean {
       return true;
     },
@@ -19,14 +20,20 @@ function makeNode(
   nodeId: string,
   body = '',
   childNodes: readonly DiffableNode[] = [],
+  nodeKind = 'widget',
 ): DiffableNode {
   return {
     id: nodeId,
+    nodeKind,
     children(): readonly DiffableNode[] {
       return childNodes;
     },
     isEqualTo(other: DiffableNode): boolean {
-      return nodeId === other.id && body === (other as typeof this & { _body?: string })._body;
+      return (
+        nodeId === other.id &&
+        nodeKind === other.nodeKind &&
+        body === (other as typeof this & { _body?: string })._body
+      );
     },
     _body: body,
   } as DiffableNode & { _body: string };
@@ -105,10 +112,9 @@ describe('diffSchemas', () => {
     expect(issues).toHaveLength(2);
   });
 
-  it('message field is a non-empty string', () => {
+  it('issues do not carry a message field', () => {
     const issues = diffSchemas(rootOf([makeNode('ns/x/y')]), rootOf([]));
-    expect(typeof issues[0]?.message).toBe('string');
-    expect((issues[0]?.message.length ?? 0) > 0).toBe(true);
+    expect(issues[0]).not.toHaveProperty('message');
   });
 
   it('missing issue carries expected node ref but no actual', () => {
@@ -162,6 +168,47 @@ describe('diffSchemas', () => {
     );
   });
 
+  it('throws when two siblings share the same id AND the same nodeKind (genuine duplicate)', () => {
+    const a = makeNode('public', 'a', [], 'role');
+    const b = makeNode('public', 'b', [], 'role');
+    expect(() => diffSchemas(rootOf([a, b]), rootOf([]))).toThrow(
+      'diffSchemas: duplicate id among siblings',
+    );
+  });
+
+  it('a same-id sibling pair with different nodeKind does not throw and pairs independently (role "public" vs namespace "public")', () => {
+    const role = makeNode('public', 'role-body', [], 'role');
+    const namespace = makeNode('public', 'namespace-body', [], 'namespace');
+    const expected = [role, namespace];
+    const actual = [
+      makeNode('public', 'role-body', [], 'role'),
+      makeNode('public', 'namespace-body-v2', [], 'namespace'),
+    ];
+
+    const issues = diffSchemas(rootOf(expected), rootOf(actual));
+
+    // The role pairs cleanly (equal bodies); the namespace pairs and mismatches.
+    // Neither is reported as missing/extra — proof the two same-id, different-kind
+    // siblings were never conflated into one map slot.
+    expect(issues).toHaveLength(1);
+    expect(issues[0]).toMatchObject({ reason: 'not-equal', path: ['root', 'public'] });
+    expect((issues[0]?.expected as DiffableNode | undefined)?.nodeKind).toBe('namespace');
+  });
+
+  it('a nodeKind-only-different sibling pair reports missing+extra when one side lacks the counterpart kind', () => {
+    // Expected has only a role named "public"; actual has only a namespace named
+    // "public". Same id, different nodeKind on each side — they must not pair
+    // against each other; each is reported independently.
+    const expected = [makeNode('public', 'role-body', [], 'role')];
+    const actual = [makeNode('public', 'namespace-body', [], 'namespace')];
+
+    const issues = diffSchemas(rootOf(expected), rootOf(actual));
+
+    expect(issues).toHaveLength(2);
+    const reasons = new Set(issues.map((i) => i.reason));
+    expect(reasons).toEqual(new Set(['not-found', 'not-expected']));
+  });
+
   it('descends into a matched pair and reports one issue at the child path (AC-2)', () => {
     // A parent present on both sides whose id() matches and isEqualTo is true,
     // but whose children differ on one child. diffSchemas descends the matched
@@ -242,7 +289,7 @@ describe('diffSchemas', () => {
 });
 
 function makeSchemaDiffIssue(path: readonly string[]): SchemaDiffIssue {
-  return { path, reason: 'not-expected', message: `extra: ${path.join('/')}` };
+  return { path, reason: 'not-expected' };
 }
 
 describe('SchemaDiff', () => {

packages/1-framework/3-tooling/cli/src/commands/db-verify.ts

@@ -438,7 +438,9 @@ async function executeDbVerifyCommand(
       schema: {
         summary: combined.result.summary,
         strict: combined.result.meta?.strict ?? false,
-        warnings: (combined.result.schema.warnings?.issues ?? []).map((issue) => issue.message),
+        warnings: (combined.result.schema.warnings?.issues ?? []).map((issue) =>
+          issue.path.join('/'),
+        ),
       },
       unclaimed: combined.unclaimed,
       meta: {

packages/1-framework/3-tooling/cli/src/utils/formatters/errors.ts

@@ -50,14 +50,14 @@ export function formatErrorOutput(error: CliErrorEnvelope, flags: GlobalFlags):
   }
   // Show issues list if present (always show a short list; show full list when verbose).
   // `issues` is a shared error-envelope field: PSL interpretation diagnostics stamp
-  // `kind` with their diagnostic code (e.g. `PSL_ORPHANED_BACKRELATION_LIST`); schema-diff
-  // issues carry no `kind` and stamp `reason` instead (e.g. `not-found`). Prefer whichever
-  // the producer supplied.
+  // `kind` and `message` (their diagnostic code and prose); schema-diff issues
+  // (`SchemaDiffIssue`) carry no `message` and stamp `reason` and `path` instead.
   if (error.meta?.['issues']) {
     const issues = error.meta['issues'] as readonly {
       kind?: string;
       reason?: string;
       message?: string;
+      path?: readonly string[];
     }[];
     if (issues.length > 0) {
       const maxToShow = isVerbose(flags, 1) ? issues.length : Math.min(3, issues.length);
@@ -67,7 +67,7 @@ export function formatErrorOutput(error: CliErrorEnvelope, flags: GlobalFlags):
       lines.push(`${formatDimText(header)}`);
       for (const issue of issues.slice(0, maxToShow)) {
         const label = issue.kind ?? issue.reason ?? 'issue';
-        const message = issue.message ?? '';
+        const message = issue.message ?? issue.path?.join('/') ?? '';
         lines.push(`${formatDimText(`    - [${label}] ${message}`)}`);
       }
       if (!isVerbose(flags, 1) && issues.length > maxToShow) {

packages/1-framework/3-tooling/cli/src/utils/formatters/verify.ts

@@ -21,13 +21,13 @@ const REASON_LABEL: Record<ExpectationFailureReason, string> = {
 };
 
 /**
- * The issue's display text: its own message (the differ's `path`), prefixed
- * with a human label for why it's flagged. Turning `reason` into a label is
- * this formatter's job, not the differ's — the differ's issue is data
- * (`path` + `reason` + nodes), not prose.
+ * The issue's display text: its own path, prefixed with a human label for
+ * why it's flagged. Turning `reason` (and the path) into prose is this
+ * formatter's job, not the differ's — the differ's issue is data (`path` +
+ * `reason` + nodes), not prose.
  */
 function formatIssueMessage(issue: SchemaDiffIssue): string {
-  return `${REASON_LABEL[issue.reason]}: ${issue.message}`;
+  return `${REASON_LABEL[issue.reason]}: ${issue.path.join('/')}`;
 }
 
 // ============================================================================

packages/1-framework/3-tooling/cli/test/control-api/client.test.ts

@@ -285,7 +285,6 @@ describe('ControlClient progress emission', () => {
             {
               path: ['root'],
               reason: 'not-found',
-              message: 'Schema mismatch',
             },
           ],
         },

packages/1-framework/3-tooling/cli/test/output.errors.test.ts

@@ -89,32 +89,41 @@ describe('formatErrorOutput - conflicts', () => {
   });
 });
 
-describe('formatErrorOutput - issues list label fallback', () => {
-  it('labels a PSL-diagnostic issue by its `kind` and a schema-diff issue by its `reason`', () => {
-    // The `meta.issues` channel is shared: PSL interpretation diagnostics stamp
-    // `kind` (their diagnostic code); schema-diff issues carry no `kind` and stamp
-    // `reason` instead. The renderer prefers `kind`, falls back to `reason`, then
-    // to a generic `issue` label.
+describe('formatErrorOutput - issues list label and body fallback', () => {
+  it('renders a PSL-diagnostic issue as `[kind] message`', () => {
+    // PSL interpretation diagnostics stamp `kind` (their diagnostic code) and `message` (their prose).
     const error: CliErrorEnvelope = {
       ...baseError,
       code: 'PN-RUN-3000',
       domain: 'RUN',
       summary: 'Failed to resolve contract source',
       meta: {
-        issues: [
-          { kind: 'PSL_ORPHANED_BACKRELATION_LIST', message: 'orphaned backrelation list' },
-          { reason: 'not-found', message: 'Table "post" is missing from database' },
-          { message: 'issue with neither kind nor reason' },
-        ],
+        issues: [{ kind: 'PSL_ORPHANED_BACKRELATION_LIST', message: 'orphaned backrelation list' }],
       },
     };
 
     const flags = parseGlobalFlags({ verbose: true, 'no-color': true });
     const stripped = stripAnsi(formatErrorOutput(error, flags));
 
     expect(stripped).toContain('[PSL_ORPHANED_BACKRELATION_LIST] orphaned backrelation list');
-    expect(stripped).toContain('[not-found] Table "post" is missing from database');
-    expect(stripped).toContain('[issue] issue with neither kind nor reason');
+  });
+
+  it('renders a schema-diff issue (no `message`) as `[reason] path/joined/with/slashes`', () => {
+    // Schema-diff issues (SchemaDiffIssue) carry no `message`; they stamp `reason` and `path`.
+    const error: CliErrorEnvelope = {
+      ...baseError,
+      code: 'PN-RUN-3000',
+      domain: 'RUN',
+      summary: 'Failed to resolve contract source',
+      meta: {
+        issues: [{ reason: 'not-found', path: ['public', 'post'] }],
+      },
+    };
+
+    const flags = parseGlobalFlags({ verbose: true, 'no-color': true });
+    const stripped = stripAnsi(formatErrorOutput(error, flags));
+
+    expect(stripped).toContain('[not-found] public/post');
   });
 });
 

packages/1-framework/3-tooling/cli/test/output.test.ts

@@ -335,7 +335,6 @@ describe('formatSchemaVerifyOutput', () => {
   const missingTableIssue: SchemaDiffIssue = {
     path: ['post'],
     reason: 'not-found',
-    message: 'post',
   };
 
   const createResult = (): VerifyDatabaseSchemaResult => ({
@@ -377,7 +376,6 @@ describe('formatSchemaVerifyOutput', () => {
     const diffIssue: SchemaDiffIssue = {
       path: ['public', 'profiles', 'policy_abc'],
       reason: 'not-found',
-      message: 'public/profiles/policy_abc',
     };
     const result: VerifyDatabaseSchemaResult = {
       ...createResult(),
@@ -390,8 +388,10 @@ describe('formatSchemaVerifyOutput', () => {
     const output = formatSchemaVerifyOutput(result, flags);
     const lines = output.split('\n').map(stripAnsi);
 
-    const issueLineIndex = lines.findIndex((line) => line.includes(missingTableIssue.message));
-    const diffLineIndex = lines.findIndex((line) => line.includes(diffIssue.message));
+    const issueLineIndex = lines.findIndex((line) =>
+      line.includes(missingTableIssue.path.join('/')),
+    );
+    const diffLineIndex = lines.findIndex((line) => line.includes(diffIssue.path.join('/')));
 
     expect(issueLineIndex).toBeGreaterThanOrEqual(0);
     expect(diffLineIndex).toBeGreaterThan(issueLineIndex);
@@ -427,7 +427,6 @@ describe('formatSchemaVerifyOutput', () => {
             {
               path: ['database', 'public', 'legacy_jobs'],
               reason: 'not-found',
-              message: 'database/public/legacy_jobs',
             },
           ],
         },
@@ -562,7 +561,6 @@ describe('formatSchemaVerifyOutput', () => {
           {
             path: ['public', 'profiles', policyWireName],
             reason: 'not-found',
-            message: `RLS policy "${policyWireName}" on table "profiles" is missing from the database`,
           },
         ],
       },
@@ -695,12 +693,10 @@ describe('formatSchemaVerifyJson', () => {
           {
             path: ['post'],
             reason: 'not-found',
-            message: 'Table "post" is missing',
           },
           {
             path: ['public', 'profiles', 'policy_abc'],
             reason: 'not-found',
-            message: 'RLS policy "policy_abc" is missing from the database',
           },
         ],
       },