From 3ea9c1966c075932d8228529c65d36a26feb736a Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 29 Aug 2026 10:39:00 +0000 Subject: [PATCH 1/2] docs(drivers): retire the dissolved #5499 freeze claims at the 15 untriaged group-A sites The #5499 investment freeze dissolved 2026-08-11 (maintainer lifted it for driver-mongodb, then driver-memory the same day - evidence in the head note of packages/spec/src/data/aggregation-conformance.ts). 24 sites still asserted it in the PRESENT tense outside the packages the earlier sweep opened. This rewrites the 15 that are mechanical: past tense, dated, naming the dissolution, keeping whatever each sentence was actually explaining. Where a sentence used the freeze to EXCUSE a divergence, the excuse is now stated as lapsed and the card that owns the disposition is named rather than a new justification being invented: - memory-driver-document-not.test.ts -> #13166 / #13195 (undecided) - memory-tenancy-guard.ts (Route A) -> #6915 - mongodb-comparand-type-conformance -> untriaged, no card owns it - read-scope-undefined-comparand -> the #6125 debt "owed at thaw" is DUE Deliberately NOT touched (7 sites): the four dated group-C records (memory-pagination-conformance.test.ts:125, mongodb-filter-text-conformance .test.ts:18, tombstone-hydration-download-agreement.test.ts:58, service-storage/vitest.config.ts:47) and the three pins #13166 owns (memory-matcher-not-null-safe.test.ts:148/:174/:188). The generated packages/spec/src/migrations/registry.ts is excluded from the sweep grep. Reported, not rewritten (2 sites): driver-mongodb/src/test-mongod.ts:45 (group-B design rationale) and qa/dogfood/test/read-coercion-conformance .test.ts:11 (retirement mis-attribution). Both need a judgement, not a sweep. Comment and test-title prose only - no behaviour change. Co-Authored-By: Claude Opus 5 Claude-Session: https://claude.ai/code/session_01LZbWd2jNV1FErXTPSS4Dry --- .../driver-memory/src/filter-refusal.ts | 6 +++++- .../memory-aggregation-filter-refusal.test.ts | 5 ++++- .../memory-comparand-type-conformance.test.ts | 12 +++++++---- .../src/memory-driver-document-not.test.ts | 15 +++++++------ .../driver-memory/src/memory-driver.ts | 7 +++++-- .../src/memory-like-pattern.test.ts | 8 ++++--- .../driver-memory/src/memory-tenancy-guard.ts | 21 ++++++++++++------- ...mongodb-comparand-type-conformance.test.ts | 12 ++++++++--- .../src/mongodb-icontains.test.ts | 10 ++++++--- packages/drivers/driver-sql/src/sql-driver.ts | 3 ++- ...lugin-security-enforcement-warning.test.ts | 5 ++++- .../read-scope-undefined-comparand.test.ts | 11 ++++++---- 12 files changed, 79 insertions(+), 36 deletions(-) diff --git a/packages/drivers/driver-memory/src/filter-refusal.ts b/packages/drivers/driver-memory/src/filter-refusal.ts index 9ef3e4e645..9e712231ae 100644 --- a/packages/drivers/driver-memory/src/filter-refusal.ts +++ b/packages/drivers/driver-memory/src/filter-refusal.ts @@ -62,7 +62,11 @@ export function unsupportedFilterError(message: string): Error { * ADR-0112): the spec declares the key, this driver's `performAggregation` * evaluates no per-aggregation predicate, so it is a capability gap in the * backend rather than a mistake in the query. Building the evaluation here is - * a capability investment this refusal deliberately is not (#5499 freeze). + * a capability investment this refusal deliberately is not. That was the + * #5499 investment freeze's call while it stood; the freeze dissolved + * 2026-08-11 (head note of `@objectstack/spec`'s `aggregation-conformance.ts`), + * so building it is now unclaimed rather than forbidden — and until someone + * claims it the refusal is still the honest answer for an uncompiled key. * Refused rather than silently aggregating the UNFILTERED rows — the #10413 * defect. Unreachable through `engine.aggregate` (the engine lowers filtered * aggregations in memory for every driver); this fires only for a caller that diff --git a/packages/drivers/driver-memory/src/memory-aggregation-filter-refusal.test.ts b/packages/drivers/driver-memory/src/memory-aggregation-filter-refusal.test.ts index 556c39c6ec..faec8c2d60 100644 --- a/packages/drivers/driver-memory/src/memory-aggregation-filter-refusal.test.ts +++ b/packages/drivers/driver-memory/src/memory-aggregation-filter-refusal.test.ts @@ -12,7 +12,10 @@ * engine itself never pushes a filtered aggregation down (it lowers in * memory); the refusal exists for direct callers. Evaluating the predicate * here instead would be a capability build-out, which the #5499 family freeze - * rules out — the refusal path is the sanctioned scope. + * ruled out while it stood; that freeze dissolved 2026-08-11 (head note of + * `@objectstack/spec`'s `aggregation-conformance.ts`), so the build-out is now + * unclaimed rather than forbidden and the refusal path remains this file's + * scope until someone claims it. * * Every case asserts `code` AND `status`, never merely "it threw" (#6144). */ diff --git a/packages/drivers/driver-memory/src/memory-comparand-type-conformance.test.ts b/packages/drivers/driver-memory/src/memory-comparand-type-conformance.test.ts index d74f5cf46f..c429ea3316 100644 --- a/packages/drivers/driver-memory/src/memory-comparand-type-conformance.test.ts +++ b/packages/drivers/driver-memory/src/memory-comparand-type-conformance.test.ts @@ -7,10 +7,14 @@ * This is the driver the card was filed over: `{qty: {$eq: BigInt(100)}}` * escaped as a raw mingo `TypeError` out of `Query.compile` (mingo builds its * cache key with `JSON.stringify`, which refuses a BigInt), and five other - * unsupported comparand types answered silent zero rows — on both faces. The - * driver is under the #5499 investment freeze, so NOTHING here patches it: the - * door (`parseFilterAST`, `@objectstack/spec/data`) refuses or narrows every - * comparand BEFORE the driver runs, and this suite proves the inheritance — + * unsupported comparand types answered silent zero rows — on both faces. + * NOTHING here patches the driver — that was the #5499 investment freeze's + * call when this suite was written, and the freeze dissolved 2026-08-11 (head + * note of `@objectstack/spec`'s `aggregation-conformance.ts`), so patching is + * now unclaimed rather than forbidden. The suite's scope is unchanged either + * way, because what it actually asserts is the door: `parseFilterAST` + * (`@objectstack/spec/data`) refuses or narrows every comparand BEFORE the + * driver runs, and this suite proves the inheritance — * door-validated input executes correctly (the bigint arrives as its exact * number, so mingo never sees one), door-refused input never reaches mingo at * all. diff --git a/packages/drivers/driver-memory/src/memory-driver-document-not.test.ts b/packages/drivers/driver-memory/src/memory-driver-document-not.test.ts index c9e586ed24..1aba67f48d 100644 --- a/packages/drivers/driver-memory/src/memory-driver-document-not.test.ts +++ b/packages/drivers/driver-memory/src/memory-driver-document-not.test.ts @@ -220,13 +220,16 @@ describe('[#5324] InMemoryDriver.find compiles a document-level $not', () => { * once the reversal's cross-backend cost had been measured, and the include * direction was re-affirmed — which leaves the split above. * - * ⛔ Nothing is flipped in either direction: this package is inside the #5499 - * investment freeze. What the round trip confirmed is exactly why this pin - * exists — this package answers with two different faces, so a statement like - * "driver-memory already reads has-value" is true of the reference matcher and - * FALSE of the live query path users actually reach. + * ⛔ Nothing is flipped in either direction. The #5499 investment freeze was + * the reason while it stood; it dissolved 2026-08-11 (head note of + * `@objectstack/spec`'s `aggregation-conformance.ts`), so that excuse has + * lapsed and the direction is now #13166's and #13195's to settle — ⛔ not + * this pin's, and ⛔ not a sweep's. What the round trip confirmed is exactly + * why this pin exists — this package answers with two different faces, so a + * statement like "driver-memory already reads has-value" is true of the + * reference matcher and FALSE of the live query path users actually reach. */ - describe('[#5299] the settled cells, live vs reference — behaviour frozen (#5499)', () => { + describe('[#5299] the settled cells, live vs reference — divergence pinned, disposition open (#13166/#13195)', () => { const liveVsReference = async (where: unknown) => ({ live: await idsFrom(nulled, where), reference: NULLED.filter((r) => match(r, where)).map((r) => r.id), diff --git a/packages/drivers/driver-memory/src/memory-driver.ts b/packages/drivers/driver-memory/src/memory-driver.ts index ebccad624c..895637a5dd 100644 --- a/packages/drivers/driver-memory/src/memory-driver.ts +++ b/packages/drivers/driver-memory/src/memory-driver.ts @@ -409,8 +409,11 @@ export class InMemoryDriver implements IDataDriver { // // `offset` above is deliberately left on truthiness: `slice(0)` IS the // identity slice, so presence and truthiness cannot be told apart there — - // no behaviour to fix. The #5499 freeze exception granted here is the limit - // door only. + // no behaviour to fix — and that is the whole reason now. The #6577 ruling + // scoped its exception to the limit door only, but it was an exception to + // the #5499 investment freeze, and that freeze dissolved 2026-08-11 (head + // note of `@objectstack/spec`'s `aggregation-conformance.ts`). So scope is + // no longer what holds this line back; the identity-slice argument is. if (query.limit !== undefined) { results = results.slice(0, query.limit); } diff --git a/packages/drivers/driver-memory/src/memory-like-pattern.test.ts b/packages/drivers/driver-memory/src/memory-like-pattern.test.ts index 2156da9642..acf9b2a95d 100644 --- a/packages/drivers/driver-memory/src/memory-like-pattern.test.ts +++ b/packages/drivers/driver-memory/src/memory-like-pattern.test.ts @@ -9,9 +9,11 @@ * family a real pattern arm. The other backends then had a choice per the * issue's own bar: implement the same semantics, or refuse loudly in the * ADR-0112 envelope — never quietly answer something else. `driver-mongodb`, - * objectql's `having` and `service-analytics` refuse, because they have no arm - * and are in the #5499 frozen family. This driver implements, for two reasons - * that do not apply to them: + * objectql's `having` and `service-analytics` refuse, because they have no + * arm; they were also inside the #5499 investment freeze when they chose, and + * that freeze dissolved 2026-08-11 (head note of `@objectstack/spec`'s + * `aggregation-conformance.ts`), so their refusal now rests on the missing arm + * alone. This driver implements, for two reasons that do not apply to them: * * 1. **It is the in-memory DOUBLE.** An application whose tests run here and * whose production runs SQL would get a 400 in test for a filter that works diff --git a/packages/drivers/driver-memory/src/memory-tenancy-guard.ts b/packages/drivers/driver-memory/src/memory-tenancy-guard.ts index 9b0070c865..4696c2181a 100644 --- a/packages/drivers/driver-memory/src/memory-tenancy-guard.ts +++ b/packages/drivers/driver-memory/src/memory-tenancy-guard.ts @@ -46,9 +46,13 @@ * Multi-tenant deployments use `@objectstack/driver-sql`, which implements * driver-level tenant scoping. When real demand for in-memory multi-tenancy * appears, the fix is to implement the isolation (option A in #6915) — not to - * weaken this gate. Route A stays behind the #5499 investment freeze; a startup - * refusal is not an investment in this driver's capabilities, it is the removal - * of a silent failure mode (maintainer ruling, 2026-08-12). + * weaken this gate. Route A sat behind the #5499 investment freeze; that freeze + * dissolved 2026-08-11 (head note of `@objectstack/spec`'s + * `aggregation-conformance.ts`), so Route A is now unbuilt and owned by #6915 + * rather than blocked by a freeze. The ruling this guard rests on is untouched + * by the dissolution — it POSTDATES it: a startup refusal is not an investment + * in this driver's capabilities, it is the removal of a silent failure mode + * (maintainer ruling, 2026-08-12). */ import { resolveTenancyPosture } from '@objectstack/types'; @@ -140,10 +144,13 @@ export function assertSingleTenantPosture(): void { * This driver has no `syncSchemasBatch()` (it does not advertise * `supports.batchSchemaSync`, so the engine syncs one object per call), which * means the batch shape is reached one object at a time in practice. The - * array-taking signature is kept anyway: it is the precedent's shape, it is - * what makes the all-offenders-in-one-message property directly testable, and - * adding a batch path here would be capability investment in a driver whose - * capabilities are frozen (#5499). + * array-taking signature is kept anyway: it is the precedent's shape, and it is + * what makes the all-offenders-in-one-message property directly testable. + * Adding a batch path here would be capability investment, which the #5499 + * freeze ruled out while it stood; that freeze dissolved 2026-08-11 (head note + * of `@objectstack/spec`'s `aggregation-conformance.ts`), so the batch path is + * now merely unasked-for — this driver still advertises no + * `supports.batchSchemaSync`. */ export function assertObjectsNotTenantScoped( schemas: Array<{ object: string; schema: unknown }>, diff --git a/packages/drivers/driver-mongodb/src/mongodb-comparand-type-conformance.test.ts b/packages/drivers/driver-mongodb/src/mongodb-comparand-type-conformance.test.ts index 0656238943..6413c5c282 100644 --- a/packages/drivers/driver-mongodb/src/mongodb-comparand-type-conformance.test.ts +++ b/packages/drivers/driver-mongodb/src/mongodb-comparand-type-conformance.test.ts @@ -17,7 +17,10 @@ * ## The worst cell, and what "inherits via the shared path" means here * * This driver has NO comparand-type policy of its own, and the ruling keeps it - * that way (#5499 freeze — nothing here patches the driver). Measured on the + * that way. Nothing here patches the driver: that was the #5499 investment + * freeze's call when this suite was written, and the freeze dissolved + * 2026-08-11 (head note of `@objectstack/spec`'s `aggregation-conformance.ts`), + * so patching is now unclaimed rather than forbidden. Measured on the * wire: `{qty: undefined}` BSON-encodes to `{}` — a predicate the author wrote * to CONSTRAIN reaching the server as MATCH EVERYTHING, the one divergence * cell that returned MORE data rather than less. The door @@ -168,8 +171,11 @@ describe('[#7872] driver-mongodb — comparand-type conformance (server-free, be /** * The reverse direction, pinned at the exact step #7956 measured it: WITHOUT * the door, the implicit-equality `undefined` still reaches the wire as `{}` - * — match everything. This driver stays frozen (#5499), so the silent edit - * is expected to persist on the direct path; the door is what stands in + * — match everything. The silent edit is expected to persist on the direct + * path: that was policy under the #5499 investment freeze, and the freeze + * dissolved 2026-08-11 (head note of `@objectstack/spec`'s + * `aggregation-conformance.ts`), so it is now an UNTRIAGED divergence rather + * than a frozen one — no card owns it. Either way the door is what stands in * front of it, and the refusal case above is the cell's platform answer. If * the mongodb package ever stops dropping undefined-valued keys, this pin * fails loudly and should be retired with its sentence in the suite header. diff --git a/packages/drivers/driver-mongodb/src/mongodb-icontains.test.ts b/packages/drivers/driver-mongodb/src/mongodb-icontains.test.ts index b95e8ec9f6..a1d32ac2cd 100644 --- a/packages/drivers/driver-mongodb/src/mongodb-icontains.test.ts +++ b/packages/drivers/driver-mongodb/src/mongodb-icontains.test.ts @@ -5,9 +5,13 @@ * `translateFilter` emits. * * Server-free is not a convenience here, it is what makes the cell testable at - * all: this package is in the #5499 frozen family and its real-mongod suites are - * OPT-IN (`OS_TEST_MONGODB_MEMORY_SERVER_ENABLED=1`), so a suite that needed a - * server would not run in CI. The pattern this translator emits is the whole + * all: this package's real-mongod suites are OPT-IN + * (`OS_TEST_MONGODB_MEMORY_SERVER_ENABLED=1`, #5517), so a suite that needed a + * server would not run in CI. (This package was also in the #5499 frozen family + * when that was written; the freeze dissolved 2026-08-11 — head note of + * `@objectstack/spec`'s `aggregation-conformance.ts` — and the opt-in gate, + * which is what actually carries the argument, is unaffected by that.) The + * pattern this translator emits is the whole * behaviour — MongoDB's own `$regex` semantics are not under test — which is the * same judgement `mongodb-filter-logic-translation.test.ts` makes for the logic * case-set. The emitted patterns are additionally EXECUTED as JS `RegExp`s diff --git a/packages/drivers/driver-sql/src/sql-driver.ts b/packages/drivers/driver-sql/src/sql-driver.ts index 0adb4e25f6..76cd790654 100644 --- a/packages/drivers/driver-sql/src/sql-driver.ts +++ b/packages/drivers/driver-sql/src/sql-driver.ts @@ -8521,7 +8521,8 @@ export class SqlDriver implements IDataDriver { * {@link assertCompilableComparand}, because the envelope's `where` value * is an object and no comparand may be. `driver-memory`'s half of that * asymmetry (a bare filter there returns the unfiltered set in silence) - * stays open under the #5499 freeze; this driver's half never was silent. + * stays open; the #5499 freeze that explained it dissolved 2026-08-11 and + * nothing has claimed it since. This driver's half never was silent. * * Held by `sql-driver-distinct-filter-narrowing.test.ts`. */ diff --git a/packages/plugins/plugin-dev/src/dev-plugin-security-enforcement-warning.test.ts b/packages/plugins/plugin-dev/src/dev-plugin-security-enforcement-warning.test.ts index b6668b86bb..ef4f4d170a 100644 --- a/packages/plugins/plugin-dev/src/dev-plugin-security-enforcement-warning.test.ts +++ b/packages/plugins/plugin-dev/src/dev-plugin-security-enforcement-warning.test.ts @@ -62,7 +62,10 @@ import '@objectstack/plugin-security'; // because DevPlugin imports // `@objectstack/runtime` on the line BEFORE it and that import throws, so the // driver import is never evaluated and a mock for it would be dead weight. It -// is a frozen driver under a retirement census (#5499/#5704/#6664), where an +// is a driver under a retirement census — #5704/#6664, whose census it is; +// #5499 was the INVESTMENT freeze, never the census, and it dissolved +// 2026-08-11 (head note of `@objectstack/spec`'s `aggregation-conformance.ts`). +// Under that census an // unnecessary module binding is the defect the census exists to catch, so the // dead mock is not harmless bookkeeping. Probed, not reasoned: a marker in the // factory printed 0 times across the whole file while the same marker in the diff --git a/packages/services/service-analytics/src/__tests__/read-scope-undefined-comparand.test.ts b/packages/services/service-analytics/src/__tests__/read-scope-undefined-comparand.test.ts index 00373a461a..8d3f023d80 100644 --- a/packages/services/service-analytics/src/__tests__/read-scope-undefined-comparand.test.ts +++ b/packages/services/service-analytics/src/__tests__/read-scope-undefined-comparand.test.ts @@ -47,10 +47,13 @@ * ⛔ `@objectstack/formula` reads the same `undefined` as a THIRD semantics — * "the key is absent from the record" — which is a meaningful distinction and * the open question in #5299. It is deliberately untouched; changing it here - * would settle #5299 as a side effect. ⛔ `driver-memory` / `driver-mongodb` - * remain pin-only under the #5499 freeze, so this compiler and `driver-memory` - * now answer this cell differently on purpose (a debt owed at thaw, recorded in - * #6125). The envelope is this module's existing one, NOT #6050's + * would settle #5299 as a side effect. ⚠️ `driver-memory` / `driver-mongodb` + * were pin-only under the #5499 freeze, so this compiler and `driver-memory` + * answer this cell differently on purpose — a debt #6125 recorded as owed AT + * THAW. The thaw has arrived: the freeze dissolved 2026-08-11 (head note of + * `@objectstack/spec`'s `aggregation-conformance.ts`), so that debt is now DUE + * rather than deferred, and nothing has been triaged against it yet. + * The envelope is this module's existing one, NOT #6050's * `INVALID_FILTER` / 400: a read scope is compiled by the platform from CEL and * stored metadata, so a 400 would bill the caller for something they neither * wrote nor can change. From 9c1ff95e8c4723fdeab2b89e4ba5f51fdd9881f3 Mon Sep 17 00:00:00 2001 From: Claude Date: Sat, 29 Aug 2026 11:14:18 +0000 Subject: [PATCH 2/2] docs(drivers,qa): apply the two rulings on the not-group-A pair Both sites were reported rather than rewritten in the first commit because each needed a judgement. The coordinator ruled both; this applies them. test-mongod.ts (group-B design rationale) - option A, restate on the surviving grounds. The retirement had two premises and only one survives: the MEASURED merge-queue hazard (the unsettleable promise, three red builds in one day ejecting unrelated PRs), which is independent of investment posture. The #5499 freeze was the other, and it only ever answered "why not build the infrastructure instead"; it dissolved 2026-08-11. Per the ruling, the new text must NOT silently preserve the prohibition: it now reads as "nobody has built it, and here is the measured reason it was not worth building", says plainly that nothing forbids building it now, and defers the coverage-versus-CI-cost question to a separate card rather than settling it here. read-coercion-conformance.test.ts (retirement mis-attribution) - option A, MATCHED to the landed twin at packages/runtime/src/datasource-autoconnect.test.ts rather than independently worded. The twin KEPT the present progressive, so the tense half of the earlier recommendation is declined: the retirement is ongoing because check:driver-memory-census still enforces it, making "is being retired" accurate rather than stale. Seven clauses now match the twin verbatim, re-anchoring to #5704/#6664 and stating "NOT by #5499: that was an INVESTMENT freeze, a different proposition on the same anchor". The seven deliberately untouched sites remain absent from the branch diff, re-verified mechanically by path; the three #13166 pins are byte-identical to the branch base. Comment prose only - no behaviour change, no ablation, no rebuild claimed. Co-Authored-By: Claude Opus 5 Claude-Session: https://claude.ai/code/session_01LZbWd2jNV1FErXTPSS4Dry --- .../drivers/driver-mongodb/src/test-mongod.ts | 24 ++++++++++++++++--- .../test/read-coercion-conformance.test.ts | 6 ++++- 2 files changed, 26 insertions(+), 4 deletions(-) diff --git a/packages/drivers/driver-mongodb/src/test-mongod.ts b/packages/drivers/driver-mongodb/src/test-mongod.ts index 453b1d2317..d6c96f6ffa 100644 --- a/packages/drivers/driver-mongodb/src/test-mongod.ts +++ b/packages/drivers/driver-mongodb/src/test-mongod.ts @@ -41,9 +41,27 @@ * merge queue at least three red builds in one day and ejected unrelated PRs. * * The maintainer's call was to RETIRE the download rather than build - * single-flight / prewarm infrastructure for a driver family whose investment is - * frozen (#5499). So: no `globalSetup` pre-download, no cross-worker lock, no - * workflow cache warming. The binary-dependent suites simply do not run unless a + * single-flight / prewarm infrastructure. Two premises stood behind that call + * and only one of them survives. + * + * The survivor is the MEASURED merge-queue hazard above: the unsettleable + * promise cost at least three red builds in one day and ejected unrelated PRs, + * which is what made this download not worth its coverage. That measurement is + * independent of any investment posture, so the retirement stands on it alone. + * + * The premise that is GONE is #5499, this driver family's investment freeze — + * the clause that used to answer "why not just build the infrastructure + * instead". It dissolved 2026-08-11 (head note of `@objectstack/spec`'s + * `aggregation-conformance.ts`). + * + * So, still: no `globalSetup` pre-download, no cross-worker lock, no workflow + * cache warming — but read that as NOBODY HAS BUILT IT, and never as "it must + * not be built". Nothing forbids building it now; the measured hazard above is + * why it was not worth building. Whether the opt-in coverage now justifies that + * infrastructure is a maintainer call about coverage versus CI cost — a + * separate card, not this file's to settle. + * + * The binary-dependent suites simply do not run unless a * human asks for them with {@link MONGOD_TESTS_ENV}, and the gate is checked * before the library is even imported, so a default run starts zero downloads. * diff --git a/packages/qa/dogfood/test/read-coercion-conformance.test.ts b/packages/qa/dogfood/test/read-coercion-conformance.test.ts index 302291ed08..b0c96639bd 100644 --- a/packages/qa/dogfood/test/read-coercion-conformance.test.ts +++ b/packages/qa/dogfood/test/read-coercion-conformance.test.ts @@ -8,7 +8,11 @@ // // The `driver-memory` arm was removed in #5704 (batch 0): driver-memory is the // project's legacy test-convenience backend and its in-project test surface is -// being replaced by sqlite `:memory:` (#5499). Nothing is lost here — SQLite is +// being retired in favour of sqlite `:memory:` — by #5704, which migrated the +// test backends, and #6664, which replaced the prose census with the ledger +// `check:driver-memory-census` enforces. NOT by #5499: that was an INVESTMENT +// freeze, a different proposition on the same anchor, and it was lifted on +// 2026-08-11 while the retirement carried on. Nothing is lost here — SQLite is // the driver that actually stores booleans as integers, so it is the arm that // carries the invariant; a mingo store that never had to coerce anything could // only ever be green.