fix(driver-sql): refusals, drift reports and log lines state each decision in words instead of a tracker number (stage 1) (#20795)

Part of #20513
Clause-②: no

**Stage 1 of 5 of this lane (`driver-sql`), under the maintainer's A / A
ruling on the card.** The card stays open for stages 2-5, so this PR
carries no closing keyword. Text only: no error `code`, field name, HTTP
status, export or control flow moves. Every changed line in the four
source files is a string-literal line.

## What this does

The SQL driver's refusals, drift reports and log lines sent the reader
to a tracker number for the reason behind them. Each rewritten string
now says that reason in words (form D, as the migration-entry rewrite
applied it). Where the sentence already stated what was decided, only
the citation goes. Where it did not, the decision is added in words:

| Where | Cited | The sentence now says |
|---|---|---|
| `sql-driver.ts` `reference_to` DDL refusal | 3896, 11567 | Raw
`registerObject` skips Zod; the FOREIGN KEY DDL the key used to gate is
retired, because it could never fire for a spec-conformant lookup. |
| `sql-driver.ts` NULL-safe UNIQUE messages (drift plan, restore,
hash-shadow, direct, bare-composite fallback) | 5030 | SQL UNIQUE is
NULL-distinct, so the old index never constrained rows without an
organization. |
| `sql-driver.ts` foreign column in the hash-shadow slot | 11627, 13015
| The column is not the driver's to replace: it may hold data. |
| `sql-driver.ts` SQLite canonicalisation info lines | 3912, 3994, 12380
| Datetime and time are now one text form, so filters and sorts compare
values rather than mixed encodings; json cells are now JSON-encoded
strings, the one encoding a json column holds on every dialect. |
| `sql-driver.ts` MySQL widening info lines | 3942, 3994 | `TIMESTAMP`
ends at 2038-01-19, keeps no milliseconds and converts through the
session timezone; a zero-precision `TIME` rounds the canonical
milliseconds to the second. |
| `cross-field-conformance-cases.ts` case notes | 5146, 7597, 1051
(cloud), 7398, 5041 | Each note states the rule it guards: `$not` is
NULL-safe because each leaf is totalised; the `=` spelling of a field
reference lowers to `$eq`; only a declared column reaches a SQL
identifier position; scalar operators on a JSON column compare the whole
serialized text; `$field` comparands compile, and the positions that
cannot compile are refused. |
| everything else (filter refusals, withheld-detail wording, TEXT-key
and row-size explanations, other hash-shadow lines, drift entries,
pagination warning, testkit error) | 4363, 4560, 5158, 5240, 5347, 5348,
5369, 5907 (uncompilable), 6050, 6212, 7398, 7929, 8197, 8220, 8790,
8931, 9350, 11067, 11374, 11535, 11541, 11565, 11627, 12121, 12999,
13015, 13056, 3696 | The sentence already said what was decided; only
the citation goes. |

The withheld-detail wording now reads "withheld from the message; the
full diagnostic is in the server log". That is exactly the Turso remote
transport's existing copy, which
`remote-transport-compile-refusal-seam.test.ts` derives from this
driver's sentence by stripping the citation, so the pin still holds.

## Three strings kept for the driver-turso stage

Three aggregate refusals keep their citation: `sql-driver.ts` about 1674
(undeclared function, 5907), 1778 (per-aggregation `filter`, 10413) and
1812 (`count_distinct` without `field`, 6409). Their twins in
`driver-turso`'s `remote-transport.ts` (about 948, 1071 and 1014) carry
the same citation. Tests compare the two faces byte for byte:

- `remote-transport-aggregate-function-refusal.test.ts` about 348, 408,
510 and 576;
- `remote-transport-undeclared-aggregate-keys.test.ts` about 201.

So one face cannot drop the number alone. Measured with a one-off
ablation on the committed head: deleting only the 5907 citation here,
rebuilding `driver-sql` (the marker present in `dist/`, 2 files) and
running those two driver-turso files gave **8 failed, 25 passed**. After
the restore (blob equal to HEAD, `git diff HEAD` empty, the marker
absent from `dist/`, working tree clean) they gave 33/33. No test file
was left behind. The order forbids moving another package's ledger rows
here, so these three rows (`#5907: 1`, `#10413: 1`, `#6409: 1`) are
handed to the `driver-turso` stage, where both twins change together.

## Pins re-pinned: 18 assertion lines in 6 test files

Each asserted a number; each now asserts the words that carry the
decision:

- `#5030` (12 lines): `sql-driver-unique-violation-predicate.test.ts`
199, 208, 218, 232, 289;
`sql-driver-14902-plain-unique-duplicate-preflight.test.ts` 222, 301,
308; `sql-driver-15479-shadow-plain-unique-duplicates.test.ts` 172, 199,
222; `sql-driver-unique-tenancy.test.ts` 694. They now assert
`NULL-distinct`. The negative pins (289, 222 in 14902, 172 and 199 in
15479) keep their meaning: the plain-unique messages do not borrow the
NULL-safe arm's story.
- `#11374` (2) and `#12999` (3):
`sql-driver-12999-stale-text-remedy.test.ts` 193, 243 and 196, 210, 224.
They now assert the declare-`maxLength` sentence, and the absence of the
stale-column sentence ("re-declaring `maxLength` changes nothing here").
- `#11535` (1): `schema-drift.base-type-mismatch.test.ts` 114. It now
asserts "receives one opaque id instead of a list".

## Ledger burn-down

`scripts/doc-authoring-prose-id.baseline.json` was regenerated with
`node scripts/check-doc-authoring.mjs --census-ledger`. It was generated
into a scratch file first, so the growth refusal ran against the
checked-in baseline, and then copied into place. Only `driver-sql` rows
moved:

| File | Occurrences before | after | (file, id) pairs before | after |
|---|---:|---:|---:|---:|
| `driver-sql/src/sql-driver.ts` | 62 | 3 | 32 | 3 |
| `driver-sql/src/cross-field-conformance-cases.ts` | 6 | 0 (row leaves)
| 5 | 0 |
| `driver-sql/src/schema-drift.ts` | 4 | 0 (row leaves) | 4 | 0 |
| `driver-sql/src/live-dialect-matrix.testkit.ts` | 1 | 0 (row leaves) |
1 | 0 |
| **driver-sql total** | **73** | **3** | **42** | **3** |

Whole ledger: files 227 to 224, pairs 611 to 572, occurrences 931 to
861. The gate's printed "pinned site(s)" (id-bearing string literals) go
794 to 732. A census of every other package's sites before and after is
identical.

**The two counts on the card, reconciled.** The census counted 52
messages, and the ledger holds 73 occurrences. The census's 52 are
`sql-driver.ts` 48 plus `schema-drift.ts` 4. It folds a `+` chain into
one message, so its 48 messages are the gate's 54 string literals. Those
52 messages carry 66 occurrences, the ledger's 62 + 4. The census
listing prints ids deduplicated per message, which gives 65. The one gap
is the hash-shadow warning, whose two ternary branches each cite 13015.
The remaining 7 occurrences are the 7 `src/`-shipped test strings (the
six case notes and the testkit error), which sit outside the census's
52-message population.

## Verification (head `733b0e6815`)

- **Build.** `turbo run build` over the `driver-turso` and
`driver-sqlite-wasm` closures (which include `driver-sql`): 9/9. Then
every package under `packages/`: 71/71. Both runs exited 0 under the
verify lock.
- **Built output.** The new sentences are in both `dist/index.js` and
`dist/index.mjs`. The three held citations are the only runtime
citations left in them; the other hits are docblocks, which the bundle
keeps.
- **Tests.**
- `@objectstack/driver-sql`: 200 files passed and 11 skipped (the live
PG / MySQL cells, no server here); 3,248 tests passed and 188 skipped.
- The six re-pinned files, run on their own: 76 passed, 4 skipped.
`sql-driver-15479-shadow-plain-unique-duplicates.test.ts` is MySQL-only.
- `@objectstack/driver-turso` (the byte-parity consumer, reading the
rebuilt `dist/`): 80 files, 2,195 tests passed, 33 skipped.
- `@objectstack/driver-sqlite-wasm` (extends `SqlDriver`): 36 files, 675
tests passed.
- **Typecheck.** `@objectstack/driver-sql typecheck` exits 0;
`--listFiles` shows it reads all 211 of the package's test files.
- **Derived gates.** `node scripts/pm/dispatch-gates.mjs --commands` (no
paths; 12 paths against merge base `085ca6bc1`) names 71 commands, and
all 71 exit 0. `check:dual-build-cjs-loads`, `check:lean-entry-closure`
and `check:type-check-debt` first answered PREREQUISITE NOT MET (exit 3)
on the partial build. After the full build they exit 0, and
`check:dts-closure` was re-run there too (71 packages swept). `--ran`
reconciliation: "71 derived, 71 run, 0 NOT-MEASURED, 0 UNRUN".
`check:doc-authoring`: "sibling-package prose ids hold the baseline —
732 pinned site(s) across 224 file(s) ... no growth, no burn-down
unrecorded".
- **Lint, narrowed.** `eslint --no-inline-config --format json` over the
10 touched TypeScript files reports 10 files, 0 errors and 0 warnings.
The population is the touched files, and the count is read from eslint's
JSON. The narrowing is safe because `eslint.config.mjs` enables no
type-aware linting: the resolved `parserOptions` are `ecmaVersion` and
`sourceType` only, with no `project` or `projectService`. So this diff
cannot move an untouched file's verdict. The repo-wide `pnpm lint` is
CI's.
- **NOT MEASURED here (CI's):** the live PG / MySQL cells of the
`driver-sql` suite, including the three re-pins in the MySQL-only 15479
file. The required `Temporal Conformance (live PG + MySQL)` job runs the
whole `driver-sql` suite against both servers. Also CI's: the Test Core
shards, the Dogfood jobs and the workspace type-check lanes.

## Acceptance notes

- **Carrier for the three held strings: the `driver-turso` stage (stage
4 of this lane).** It should rewrite each pair together, the
`driver-sql` string and its `remote-transport.ts` twin, and that PR's
ledger diff then moves one `driver-sql` row as well. That is the same
serial ledger, one stage later.
- **Two twins now differ by the citation only.** The
declared-but-uncompiled refusal (5907, about 1749 here and 987 there)
and the date-bucket refusal (6212, about 1867 here and 1108 there).
Their contract is first-sentence parity, which holds; the remote copies
drop the number in the `driver-turso` stage.
- **Cited cards read.** Of the 41 distinct cited ids, 35 read as closed
and completed. Five answer 404: 11067, 11374, 12380, 12999 and 13015.
They were read through their landing commits and today's docblocks. The
cloud-repository card behind the `$field` identifier note is not
readable from this session; that note is rewritten from its own
sentence. Each rewritten sentence describes today's code: `$field`
comparands are compiled (the enforce-or-remove question was answered
"enforce"), the `=` lowering fix landed, and the FK DDL is retired.
- **Comments untouched.** Code comments and docblocks citing the same
numbers are not runtime strings and are not changed here.

---
_Generated by [Claude
Code](https://claude.ai/code/session_01DEvba2nBuD4tWzfq8r8NFY)_

Co-authored-by: Claude <noreply@anthropic.com>

Author: objectstack-fleet[bot]

.changeset/20513-driver-sql-runtime-strings-state-the-decision.md

@@ -0,0 +1,26 @@
+---
+'@objectstack/driver-sql': patch
+---
+
+driver-sql refusals, drift reports and log lines no longer cite tracker numbers; each states the reason in words
+
+Clause-②: no
+
+Many messages the SQL driver shows to authors and operators ended with an issue-tracker number where
+the reason belonged. The number goes, and where the sentence did not already say what was decided, it
+now does:
+
+- Filter refusals (`INVALID_FILTER`): the withheld-detail wording ("withheld from the message; the full
+  diagnostic is in the server log"), the JSON-column, zero-operator, `$null` / `$exists`, undefined
+  comparand and unknown-combinator refusals, and the filter-array refusal.
+- Schema and index messages: the `reference_to` DDL refusal (the FOREIGN KEY DDL that key used to gate
+  is retired, because it could never fire for a spec-conformant lookup), the MySQL TEXT-key and
+  row-size explanations, the hash-shadow UNIQUE messages, and the `os migrate plan` drift entries.
+- The NULL-safe UNIQUE messages now say why rows without an organization were never constrained: SQL
+  UNIQUE is NULL-distinct.
+- Boot log lines for the SQLite datetime, time and json canonicalisation and the MySQL `TIMESTAMP` /
+  `TIME` widening now say what the conversion is for.
+
+Text only: no error code, field name, status or behaviour changes. Three aggregate refusals keep their
+citation for now, because a test in `@objectstack/driver-turso` compares them byte for byte with the
+Turso remote transport's copies; they change together with those copies.

packages/drivers/driver-sql/src/cross-field-conformance-cases.ts

@@ -189,7 +189,7 @@ export const CROSS_FIELD_CASES: readonly CrossFieldCase[] = [
     name: '$not of a cross-field $gt returns exactly the rows $gt does not',
     filter: { $not: { amount: { $gt: { $field: 'budget' } } } },
     expected: ['2', '3', '4', '5', '6'],
-    note: '#5146 made `$not` NULL-safe by totalising its leaves; a cross-field leaf is total by construction, so the negation is the exact complement — including the NULL rows the JS evaluator returns.',
+    note: '`$not` is NULL-safe because each of its leaves is totalised (TRUE or FALSE, never NULL), as the JS evaluator reads it; a cross-field leaf is total by construction, so the negation is the exact complement — including the NULL rows the JS evaluator returns.',
   },
   {
     name: '$not of a cross-field $eq returns exactly the rows $eq does not',
@@ -235,7 +235,7 @@ export const CROSS_FIELD_CASES: readonly CrossFieldCase[] = [
       },
     },
     expected: ['2', '4', '5'],
-    note: 'The complement of {1} ∪ {3,6}. A guard hoisted to the top of the `$not` instead of sitting on each leaf re-admits rows here — the failure #5146 wrote its rewrite to avoid.',
+    note: 'The complement of {1} ∪ {3,6}. A guard hoisted to the top of the `$not` instead of sitting on each leaf re-admits rows here — the failure that totalising each leaf, rather than guarding the whole `$not`, exists to avoid.',
   },
   {
     name: 'a cross-field comparison nested two combinators deep',
@@ -314,7 +314,7 @@ export const CROSS_FIELD_AUTHORED_CASES: readonly CrossFieldAuthoredCase[] = [
     authored: ['amount', '>', { $field: 'budget' }],
     loweredTo: { amount: { $gt: { $field: 'budget' } } },
     expected: ['1'],
-    note: 'Untouched by #7597 and asserted anyway: if this moves, the harness moved rather than the lowering.',
+    note: 'Untouched by the fix that lowers the `=` spelling of a field reference to `$eq`, and asserted anyway: if this moves, the harness moved rather than the lowering.',
   },
 
   // ── The sugar's own structures, carrying a reference leaf ────────────────
@@ -393,7 +393,7 @@ export const CROSS_FIELD_REFUSALS: readonly CrossFieldRefusalCase[] = [
     name: 'an undeclared column is refused at compile time',
     filter: { amount: { $gt: { $field: 'no_such_column' } } },
     diagnosticIncludes: ['not a declared field'],
-    note: 'The `$field` value lands in a SQL IDENTIFIER position. cloud#1051: letting it through unchecked is dismantling the guard rail — and a compile-time refusal is what makes AI-authored metadata wrong at authoring time rather than in the database.',
+    note: 'The `$field` value lands in a SQL IDENTIFIER position, and letting it through unchecked would dismantle the guard rail that only a declared column reaches SQL — and a compile-time refusal is what makes AI-authored metadata wrong at authoring time rather than in the database.',
   },
   {
     name: 'an undeclared TARGET field is refused too',
@@ -446,7 +446,7 @@ export const CROSS_FIELD_REFUSALS: readonly CrossFieldRefusalCase[] = [
     name: 'a multi-valued (JSON) column is refused as the referent',
     filter: { amount: { $gt: { $field: 'tags' } } },
     diagnosticIncludes: ['no scalar stored'],
-    note: 'A JSON column holds a serialized array; SQL comparison operators have no element-wise reading of it, and #7398 already refuses the scalar operators on such a column for a value comparand.',
+    note: 'A JSON column holds a serialized array; SQL comparison operators have no element-wise reading of it, and the scalar operators are already refused on such a column for a value comparand, because they compare the whole serialized text.',
   },
   {
     name: 'a formula (virtual) column is refused as the referent',
@@ -479,7 +479,7 @@ export const CROSS_FIELD_REFUSALS: readonly CrossFieldRefusalCase[] = [
     name: 'a $field member of an $in list is refused',
     filter: { amount: { $in: [{ $field: 'budget' }, 1] } },
     diagnosticIncludes: ['index 0'],
-    note: 'Before #5041 this did not even crash: it compiled, ran, and returned ZERO ROWS. The index is named because it is the only thing distinguishing the bad member from its legitimate neighbours.',
+    note: 'Before this driver compiled `$field` comparands and refused the positions it cannot compile, this did not even crash: it compiled, ran, and returned ZERO ROWS. The index is named because it is the only thing distinguishing the bad member from its legitimate neighbours.',
   },
   {
     name: 'a $field member of a $nin list is refused',

packages/drivers/driver-sql/src/live-dialect-matrix.testkit.ts

@@ -216,7 +216,7 @@ export function currentLiveSchema(): string {
   const testPath = expect.getState().testPath;
   if (!testPath) {
     throw new Error(
-      'live-dialect isolation (#9350): vitest reported no testPath, so this live connection ' +
+      'live-dialect isolation: vitest reported no testPath, so this live connection ' +
         'cannot be given a per-file schema and would fall back to sharing one database with ' +
         'every other live file — the contention this removed. Build live connections from a ' +
         'test file, through DIALECT_CELLS[].config().',

packages/drivers/driver-sql/src/schema-drift.base-type-mismatch.test.ts

@@ -111,7 +111,7 @@ describe('diffManagedTable — multi-value field over a stale textual column (#1
     expect(entry.message).toContain('proj_task.tags');
     expect(entry.message).toContain('json');
     expect(entry.message).toContain('character varying');
-    expect(entry.message).toContain('#11535');
+    expect(entry.message).toContain('receives one opaque id instead of a list');
     // The remedy is the real statement, not a gesture at one.
     expect(entry.message).toContain(manualJsonConversionSql('postgres', 'proj_task', 'tags'));
     // The orphaned single-value index is part of the same picture: a json

packages/drivers/driver-sql/src/schema-drift.ts

@@ -995,7 +995,7 @@ export function diffManagedTable(args: {
         message:
           `${table}.${fieldName}: the column carries DEFAULT '${field.defaultValue}', but ` +
           `'${field.defaultValue}' is a runtime token the engine resolves per write — the database ` +
-          `has been stamping the literal token into every insert that omitted the field (#4560). ` +
+          `has been stamping the literal token into every insert that omitted the field. ` +
           `Dropping the default is non-destructive: run "os migrate apply". Rows already holding ` +
           `'${field.defaultValue}' are NOT rewritten — the dangling-reference audit reports them.`,
       });
@@ -1142,7 +1142,7 @@ export function diffManagedTable(args: {
           `column is \`${col.type}\` — the database was created while the field was single-value and the ` +
           `additive sync never migrates a column's type. Arrays are being written as the STRINGIFIED ` +
           `literal (e.g. '["a","b"]') and read back as a string, so anything consuming the value ` +
-          `receives one opaque id instead of a list (#11535). REMEDY: run ` +
+          `receives one opaque id instead of a list. REMEDY: run ` +
           `"${MULTI_VALUE_COLUMN_REMEDY_COMMAND}" — it is a DRY RUN by default that executes nothing ` +
           `and prints the statements; take a backup, then re-run it with --apply. ObjectStack never ` +
           `migrates this column on its own: the boot path only reports it and "os migrate apply" ` +
@@ -1347,8 +1347,8 @@ export function diffManagedTable(args: {
           `\`varchar(${col.maxLength})\` and the additive sync never changes a column's type. The ` +
           `column still caps at ${col.maxLength} characters, so the server refuses longer values the ` +
           `declaration ALLOWS (Postgres 22001, MySQL ER_DATA_TOO_LONG) — a data URI in a ` +
-          `\`signature\`/\`qrcode\` field, or an ordinary rich-text body, is routinely past it ` +
-          `(#12121). ObjectStack does NOT migrate this column: "os migrate apply" reports this entry ` +
+          `\`signature\`/\`qrcode\` field, or an ordinary rich-text body, is routinely past it. ` +
+          `ObjectStack does NOT migrate this column: "os migrate apply" reports this entry ` +
           `as skipped. Two operator routes — declare a \`maxLength\` this dialect can express, which ` +
           `turns this into the widen op "os migrate apply" performs; or convert the column to TEXT by ` +
           `hand, with a backup taken first, restating the FULL column definition on MySQL (MODIFY ` +
@@ -2391,7 +2391,7 @@ export function diffManagedIndexes(args: {
       message:
         `${table}.${l.legacyColumns.join('+')}: a legacy platform-wide UNIQUE index (${present.join(', ')}) still enforces ` +
         `uniqueness across ALL tenants, but metadata scopes it per '${l.replacement.columns[0]}' — a second ` +
-        `tenant reusing the value is rejected on insert (#3696). Replacing it with ${indexSignature(l.replacement.columns, true, l.replacement.nullSafeColumns)} ` +
+        `tenant reusing the value is rejected on insert. Replacing it with ${indexSignature(l.replacement.columns, true, l.replacement.nullSafeColumns)} ` +
         `is a pure relaxation: run "os migrate apply".`,
     });
   }

packages/drivers/driver-sql/src/sql-driver-12999-stale-text-remedy.test.ts

@@ -190,10 +190,10 @@ describe('unkeyable TEXT column: the upgrade path names the real remedy (#12999)
 
     expect(message).toMatch(/Column\(s\) "token" are stored as TEXT because the field declares no `maxLength`/);
     expect(message).toMatch(/Declare `maxLength` on the field\(s\) so the column is emitted as varchar\(n\)/);
-    expect(message).toContain('#11374');
+    expect(message).toContain('so the column is emitted as varchar(n) and can be keyed.');
     // ⛔ The new branch must not reach this deployment: nothing here is stale.
     expect(message).not.toMatch(/ALREADY declares/);
-    expect(message).not.toContain('#12999');
+    expect(message).not.toContain('re-declaring `maxLength` changes nothing here');
   });
 
   it('COUNTER-PIN: a bound past the 768-character key ceiling is NOT a stale column', async () => {
@@ -207,7 +207,7 @@ describe('unkeyable TEXT column: the upgrade path names the real remedy (#12999)
 
     expect(message).toMatch(/wider than 768 characters/);
     expect(message).not.toMatch(/ALREADY declares/);
-    expect(message).not.toContain('#12999');
+    expect(message).not.toContain('re-declaring `maxLength` changes nothing here');
   });
 
   it('COUNTER-PIN: a table this driver holds no declaration for keeps the CREATE message', async () => {
@@ -221,7 +221,7 @@ describe('unkeyable TEXT column: the upgrade path names the real remedy (#12999)
     const message = (await explain(driver, 'os12999_unregistered', ['token'])) ?? '';
 
     expect(message).toMatch(/Declare `maxLength` on the field\(s\)/);
-    expect(message).not.toContain('#12999');
+    expect(message).not.toContain('re-declaring `maxLength` changes nothing here');
   });
 
   it('names BOTH dispositions when one key column is stale and another is unbounded', async () => {
@@ -240,7 +240,7 @@ describe('unkeyable TEXT column: the upgrade path names the real remedy (#12999)
     // …and the genuinely unbounded half is still told to declare a bound, so a
     // composite key does not send the operator down one route for both columns.
     expect(message).toMatch(/Column\(s\) "note" in the same key declare no usable bound and DO need `maxLength`/);
-    expect(message).toContain('#11374');
+    expect(message).toContain('DO need `maxLength` declared on the field.');
   });
 
   it('still declines to explain a failure that is not the TEXT-key refusal', async () => {

packages/drivers/driver-sql/src/sql-driver-14902-plain-unique-duplicate-preflight.test.ts

@@ -219,7 +219,7 @@ describe('#14902 plain unique index over duplicate rows', () => {
       expect(entry!.message).toContain('os migrate plan');
       // ⛔ And it must NOT borrow path A's story: no prior index admitted these
       // rows, so #5030 is not what happened here.
-      expect(entry!.message).not.toContain('#5030');
+      expect(entry!.message).not.toContain('NULL-distinct');
       expect(entry!.message).not.toContain('NULL-safe');
     });
 
@@ -298,14 +298,14 @@ describe('#14902 plain unique index over duplicate rows', () => {
       const durability = logs.filter((l) => l.level === 'error');
       expect(durability).toHaveLength(1);
       expect(durability[0].msg).toContain('NULL-safe unique index');
-      expect(durability[0].msg).toContain('#5030');
+      expect(durability[0].msg).toContain('NULL-distinct');
       expect(durability[0].msg).toContain('ADR-0120 D4');
       expect(durability[0].msg).toContain("'organization_id, quote_number'");
 
       const entry = (await driver.detectManagedDrift()).find((d) => d.op.type === 'create_index')!;
       expect(entry.category).toBe('destructive');
       expect(entry.severity).toBe('error');
-      expect(entry.message).toContain('#5030');
+      expect(entry.message).toContain('NULL-distinct');
       expect(entry.message).toContain('__global__');
       // Both key groups, with counts — the NULL-organization bucket and a real
       // organization, which is what makes the COALESCE key self-describing.

packages/drivers/driver-sql/src/sql-driver-15479-shadow-plain-unique-duplicates.test.ts

@@ -169,7 +169,7 @@ declareDialectCell(MYSQL_CELL, 'hash-shadow plain unique over duplicates (#15479
 
       // ⛔ And it must NOT carry the NULL-safe arm's framing, which is false
       // here: nothing admitted these rows and there is no NULL-safe key.
-      expect(diagnosis).not.toContain('#5030');
+      expect(diagnosis).not.toContain('NULL-distinct');
       expect(diagnosis).not.toContain('NULL-safe');
       expect(diagnosis).not.toContain('COALESCE');
 
@@ -196,7 +196,7 @@ declareDialectCell(MYSQL_CELL, 'hash-shadow plain unique over duplicates (#15479
       const diagnosis = logs.find((l) => l.includes("cannot create hash-shadow unique index 'uniq_os15479_global_v'"));
       expect(diagnosis, 'the degradation must reach the durability channel').toBeTruthy();
       expect(diagnosis).toMatch(/Conflicting group\(s\):/);
-      expect(diagnosis).not.toContain('#5030');
+      expect(diagnosis).not.toContain('NULL-distinct');
       expect(diagnosis).not.toContain('COALESCE');
 
       const { idx } = await catalog('os15479_global');
@@ -219,7 +219,7 @@ declareDialectCell(MYSQL_CELL, 'hash-shadow plain unique over duplicates (#15479
       expect(err, 'the NULL-safe arm already survived the boot').toBeNull();
       const diagnosis = logs.find((l) => l.includes("cannot create hash-shadow unique index 'uniq_os15479_org_v'"));
       expect(diagnosis, 'the NULL-safe degradation must still be logged').toBeTruthy();
-      expect(diagnosis).toContain('#5030');
+      expect(diagnosis).toContain('NULL-distinct');
       expect(diagnosis).toContain('NULL-safe');
       expect(diagnosis).toContain("COALESCE(organization_id, '__global__')");
     }, 60_000);

packages/drivers/driver-sql/src/sql-driver-unique-tenancy.test.ts

@@ -691,7 +691,7 @@ describe('SqlDriver unique × tenancy (#3696)', () => {
       expect(entry!.message).toMatch(/BLOCKED/);
       expect(entry!.message).toMatch(/__global__/);
       expect(entry!.message).toMatch(/"DUP"/);
-      expect(entry!.message).toMatch(/#5030/);
+      expect(entry!.message).toMatch(/NULL-distinct/);
 
       // Even `--allow-destructive` cannot force it: apply re-probes and
       // refuses — at no point is a constraint dropped without its replacement

packages/drivers/driver-sql/src/sql-driver-unique-violation-predicate.test.ts

@@ -196,7 +196,7 @@ describe('syncDeclaredIndexes unique-violation discriminator (#6543)', () => {
     expect(errors[0]).toMatch(/cannot create NULL-safe unique index/);
     expect(errors[0]).toMatch(/uniq_product_organization_id_code/);
     expect(errors[0]).toMatch(/NOT enforced/);
-    expect(errors[0]).toMatch(/#5030/);
+    expect(errors[0]).toMatch(/NULL-distinct/);
     expect(errors[0]).toMatch(/ADR-0120 D4/);
   });
 
@@ -205,7 +205,7 @@ describe('syncDeclaredIndexes unique-violation discriminator (#6543)', () => {
 
     await expect(sync([NULL_SAFE_INDEX])).resolves.toBeUndefined();
     expect(errors).toHaveLength(1);
-    expect(errors[0]).toMatch(/#5030/);
+    expect(errors[0]).toMatch(/NULL-distinct/);
   });
 
   it('reads the violation through a driver `cause` wrapper', async () => {
@@ -215,7 +215,7 @@ describe('syncDeclaredIndexes unique-violation discriminator (#6543)', () => {
 
     await expect(sync([NULL_SAFE_INDEX])).resolves.toBeUndefined();
     expect(errors).toHaveLength(1);
-    expect(errors[0]).toMatch(/#5030/);
+    expect(errors[0]).toMatch(/NULL-distinct/);
   });
 
   // ── Nothing the old regex caught may be narrowed ──────────────────────────
@@ -229,7 +229,7 @@ describe('syncDeclaredIndexes unique-violation discriminator (#6543)', () => {
 
     await expect(sync([NULL_SAFE_INDEX])).resolves.toBeUndefined();
     expect(errors).toHaveLength(1);
-    expect(errors[0]).toMatch(/#5030/);
+    expect(errors[0]).toMatch(/NULL-distinct/);
   });
 
   // ── The site's own business logic, untouched by the migration ─────────────
@@ -286,7 +286,7 @@ describe('syncDeclaredIndexes unique-violation discriminator (#6543)', () => {
     expect(errors[0]).toMatch(/× 2 rows/);
     // ⛔ And it does not borrow the NULL-safe arm's story: no earlier index
     // admitted these rows, so #5030 is not what happened here.
-    expect(errors[0]).not.toMatch(/#5030/);
+    expect(errors[0]).not.toMatch(/NULL-distinct/);
     expect(errors[0]).not.toMatch(/NULL-safe/);
   });