docs: restate the dissolved #5499 freeze prose on surviving grounds (A/B/C, generated registry and #13166's cell untouched)

packages/objectql/src/engine-autonumber-resync.test.ts

@@ -680,9 +680,11 @@ describe('ObjectQL autonumber resync (#6806)', () => {
 
  // The honest outcome: the number is issued a second time, the write
  // SUCCEEDS, and nothing anywhere says so. Fixing this needs uniqueness in
- // the driver — `packages/drivers/**` is under the #5499 freeze, and a
- // pre-issue existence probe in the engine would cost a query per insert
- // and still be racy. Reported as a follow-up, not implemented here.
+ // the driver, and a pre-issue existence probe in the engine would cost a
+ // query per insert and still be racy. (`packages/drivers/**` was under
+ // the #5499 freeze when this was written; it was lifted on 2026-08-11,
+ // and the remedy is still the driver's.) Reported as a follow-up, not
+ // implemented here.
  expect(written.doc_no).toBe('D-0005');
  expect(rows.filter((r) => r.doc_no === 'D-0005')).toHaveLength(2);
  // One create attempt: with no rejection there is nothing to retry.

packages/objectql/src/engine.ts

@@ -4462,8 +4462,10 @@ export class ObjectQL implements IObjectQLEngine {
  * driver, NOT a pre-issue existence probe here: a probe costs a query on every
  * insert (the cost this resync was designed to avoid) and is still racy, so it
  * would trade a silent duplicate for a rarer silent duplicate at double the
- * read cost. `packages/drivers/**` is under the #5499 investment freeze, so
- * that work is not this change's to do.
+ * read cost. `packages/drivers/**` was under the #5499 investment freeze when
+ * this was written, so that work was not this change's to do; the freeze was
+ * lifted on 2026-08-11 and the remedy is still the driver's, still not done
+ * here.
  *
  * # And when it does not converge
  *

packages/objectql/src/filter-comparand-shape.ts

@@ -11,7 +11,8 @@
  * `assertListComparandShapes` below is a DELEGATING WRAPPER. The rule "a list
  * operator takes a list" has exactly one implementation, and it is
  * `@objectstack/spec/data`'s `filter-comparand-shape.ts`, whose module note
- * carries the divergence table, the #5499 freeze argument and the
+ * carries the divergence table, the shared-face argument (including the record
+ * of the dissolved #5499 freeze it was first argued from) and the
  * deliberately-not-refused list. Read that file for the rule; read this
  * function for the engine's two call sites and its wording contract.
  *

packages/objectql/src/search-filter.ts

@@ -30,8 +30,9 @@
  * `$icontains` (#6520 / #6682): both `driver-sql` compilers (and
  * `driver-sqlite-wasm` / turso-local by inheritance), turso's independent
  * `RemoteTransport`, service-analytics' read-scope and cube lowerings,
- * `formula`'s RLS matcher, objectql's own HAVING evaluator, and the frozen
- * `driver-memory` / `driver-mongodb` (#5499).
+ * `formula`'s RLS matcher, objectql's own HAVING evaluator, and
+ * `driver-memory` / `driver-mongodb` — which got it as a sanctioned one-off
+ * while they were under the #5499 investment freeze, lifted 2026-08-11.
  *
  * Pinyin recall (#2486): when the object carries the hidden `__search`
  * companion column (provisioned by the SchemaRegistry when

packages/objectql/src/temporal-comparand-door.ts

@@ -57,9 +57,10 @@
  * makes the zero non-vacuous).
  *
  * The only other seam holding both facts is the driver layer — four packages
- * each mirroring one function, under the #5499 investment freeze, where the
- * pass-through is a DELIBERATE contract with counter-pins asserting it
- * (`sql-driver-temporal-dialect.test.ts` asserts
+ * each mirroring one function (they sat under the #5499 investment freeze when
+ * this door was placed; it was lifted on 2026-08-11, and it is not what rules
+ * that seam out), where the pass-through is a DELIBERATE contract with
+ * counter-pins asserting it (`sql-driver-temporal-dialect.test.ts` asserts
  * `temporalFilterValue('t','at','not-a-date') === 'not-a-date'` on purpose) and
  * where `storageDatetimeValue` is shared with the WRITE path and the legacy
  * read-repair, so refusing there would also reject ingest of pre-convention

packages/runtime/src/datasource-autoconnect.test.ts

@@ -16,9 +16,13 @@
 // to `@objectstack/driver-sql` + better-sqlite3 `:memory:` — the repo's
 // canonical ephemeral store (`examples/app-crm`, `cli db clean`). driver-memory
 // is the project's legacy test-convenience backend and its in-project test
-// surface is being retired (#5499). `:memory:` keeps every acceptance below
-// hermetic: the database lives and dies inside the process, so nothing reaches
-// the host filesystem and each boot starts empty.
+// surface is being retired — 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. `:memory:` keeps every
+// acceptance below hermetic: the database lives and dies inside the process, so
+// nothing reaches the host filesystem and each boot starts empty.
 
 import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach } from 'vitest';
 import { existsSync, rmSync } from 'node:fs';

packages/runtime/src/package-service.null-seam.test.ts

@@ -17,9 +17,11 @@
  * ## Why the driver here is a LOCAL DOUBLE, not `@objectstack/driver-memory`
  *
  * The first version of this file booted the real `InMemoryDriver`. That made it
- * a THIRD consumer of a package whose investment is frozen (#5499), arriving
- * after #5704 migrated the test backends and #6664 replaced the prose census
- * with a ledger — and `check:driver-memory-census` refused it, correctly.
+ * a THIRD consumer of a package whose investment was frozen at the time (#5499,
+ * lifted 2026-08-11), arriving after #5704 migrated the test backends and #6664
+ * replaced the prose census with a ledger — and `check:driver-memory-census`
+ * refused it, correctly. That gate is what still refuses it: the census is
+ * #5704/#6664's and it outlived the freeze.
  *
  * The disposition taken was MIGRATE, not ledger. The two consumers a maintainer
  * ruled permanent are both kept because nothing can stand in for them: one needs

packages/spec/src/data/filter-comparand-shape.ts

@@ -38,8 +38,15 @@
  * The table above IS the argument for a shared face: three backends, three
  * answers, one declared contract. `driver-memory` already carries a shape gate
  * (`filter-refusal.ts`), but it is that package's own and no other driver reads
- * it — and both driver families are under a maintainer investment freeze
- * (#5499), so the policy cannot be grown per driver.
+ * it. The second reason this was first argued from — both driver families sat
+ * under the #5499 maintainer investment freeze, so the policy could not be
+ * grown per driver — no longer holds: that freeze was lifted on 2026-08-11
+ * (recorded in `./aggregation-conformance.ts`). The table is the reason that
+ * survives, and it was always the load-bearing one: growing the policy per
+ * driver means one declared contract with an implementation per backend, which
+ * is what the three rows above measured. #8234 settled the same question one
+ * branch over for comparand TYPE — "enforced once at the shared compile face
+ * for all five drivers" — and this file is that answer for comparand SHAPE.
  *
  * [#9228] It now lives in `packages/spec` rather than in the engine. The gate
  * shipped at `@objectstack/objectql`'s lowering seam (PR #6209), which covers

packages/spec/src/data/filter-comparand-type-conformance.ts

@@ -26,8 +26,11 @@
  * - `door-refusal` cases: assert `parseFilterAST(filter)` throws the envelope
  * (`code` AND `status`, plus {@link ComparandTypeRefusalCase.mustMention}) —
  * proving the input can never reach this driver through a platform door.
- * This is how the frozen drivers (#5499) inherit the policy without a
- * driver-local patch.
+ * This is how a driver that carries no comparand-type policy of its own
+ * inherits this one without a driver-local patch. The property was argued
+ * for while `driver-memory` and `driver-mongodb` were frozen (#5499, lifted
+ * 2026-08-11) and does not depend on that: the door sits upstream of every
+ * driver, so no driver has to hold a second copy of the rule.
  * - `matches` / `compiles` cases: hand `parseFilterAST(filter)` — the
  * door-validated, bigint-narrowed condition — to the driver's own execution
  * path and assert the row ids (`matches`) or merely that execution succeeds

packages/spec/src/data/filter-comparand-type.ts

@@ -25,11 +25,19 @@
  * `driver-mongodb` let the BSON encoder silently EDIT the document —
  * `{qty: undefined}` encoded to `{}`, a filter that matches EVERY row (the
  * matrix's worst cell: an amplifying, disclosure-shaped wrong answer when a
- * tenant or RLS predicate sits in the same object). Both driver families that
- * lack a policy are under the #5499 investment freeze, so the policy cannot be
- * grown per driver; it is promoted here, to the face the SQL family already
- * agrees with, and the frozen drivers inherit it by receiving already-validated
- * input (they sit behind the engine's lowering seam — see
+ * tenant or RLS predicate sits in the same object). Neither driver family that
+ * lacks a policy has one to grow. This door was first argued from the #5499
+ * investment freeze — those drivers were frozen, so the policy could not be
+ * grown per driver — and that premise is gone: the maintainer lifted the freeze
+ * for `driver-mongodb` and `driver-memory` on 2026-08-11 (recorded in
+ * `./aggregation-conformance.ts`). The shared face survives losing it on the
+ * matrix's own terms. A policy grown per driver is one accepted set with an
+ * implementation per backend, and #7956 measured what that produces: two camps,
+ * one hole, and a silent-edit cell no reading had found. The #7872 ruling puts
+ * the definition at this face for that reason, not for the freeze. So the set
+ * stays promoted here, to the face the SQL family already agrees with, and the
+ * two drivers that carry no policy of their own inherit it by receiving
+ * already-validated input (they sit behind the engine's lowering seam — see
  * `@objectstack/objectql`'s `lowerWhereFilterArray` — and behind
  * {@link parseFilterAST}, which calls this walk on everything it returns).
  *
@@ -45,10 +53,10 @@
  * `RemoteTransport`'s `Date` → ISO 8601), and refuses one beyond ±2^53 loudly
  * rather than letting the precision loss answer silently. This is what makes
  * "each of the six accepted types compiles on every driver path" true on the
- * memory path too, without touching the frozen driver: after this door, no
- * `bigint` reaches mingo at all. Direct driver callers (not going through the
- * platform's doors) keep the drivers' native `bigint` binding, which stays
- * pinned in `driver-turso`'s own suite.
+ * memory path too, with no driver-local patch in `driver-memory`: after this
+ * door, no `bigint` reaches mingo at all. Direct driver callers (not going
+ * through the platform's doors) keep the drivers' native `bigint` binding,
+ * which stays pinned in `driver-turso`'s own suite.
  *
  * ## What is a LITERAL comparand — the positions this door judges
  *

packages/spec/src/data/filter-logic-conformance.ts

@@ -199,19 +199,23 @@
  * `check` and the read-side lowering; splitting them re-opens the hole PR #5962
  * closed, with the sign reversed), rewrite four independent copies of
  * `nullValueSatisfiesOperator`, re-rule the two enrolled `$ne` / `$not` rows,
- * and touch the live query paths of two backends inside the #5499 investment
- * freeze. What it buys is a WORSE failure mode: a filter that silently drops
- * rows the author expected, in place of one that returns rows they can see and
- * narrow — silent absence for visible surplus. With no business pull behind it,
- * the maintainer kept include.
+ * and touch the live query paths of two backends that were then inside the
+ * #5499 investment freeze (lifted 2026-08-11, after this table was decided).
+ * What it buys is a WORSE failure mode: a filter that silently drops rows the
+ * author expected, in place of one that returns rows they can see and narrow —
+ * silent absence for visible surplus. With no business pull behind it, the
+ * maintainer kept include.
  *
  * ⚠️ One cell of the three is still short of its ruling, and it is the cell that
  * SURVIVED. `$exists` = has-value is settled and shipped on the surfaces the
  * ruling named — `formula` and `driver-memory`'s reference matcher both read it
  * that way (#5298 ③ / #5369, landed in #5962). Still reading key-presence:
- * `driver-memory`'s live mingo path and `driver-mongodb`, both frozen by #5499,
- * and both among the FIVE drivers this gate scores. So a `$exists` row cannot be
- * enrolled here yet.
+ * `driver-memory`'s live mingo path and `driver-mongodb`, both among the FIVE
+ * drivers this gate scores. The #5499 investment freeze that once explained why
+ * neither had moved was lifted on 2026-08-11 (recorded in
+ * `./aggregation-conformance.ts`), so the gap is now unexcused rather than
+ * deferred — but it is still a gap, so a `$exists` row cannot be enrolled here
+ * yet.
  *
  * ⛔ And the blocker on that row is NOT a missing wording, which is worth
  * stating because the obvious workaround does not exist: **the DEBT ledger in

packages/spec/src/data/index.ts

@@ -7,9 +7,11 @@ export * from './filter.zod';
 // of #7956's divergence matrix), the walk `parseFilterAST` and the engine's
 // lowering seam enforce it with, and the sentence the SQL family's refusals
 // quote instead of hand-copying. Everything outside the set is refused with
-// the `INVALID_FILTER` / 400 envelope at the compile face, so the frozen
-// drivers (#5499) inherit one answer instead of crashing (memory × BigInt) or
-// letting the BSON encoder edit the query (mongo × undefined → match-all).
+// the `INVALID_FILTER` / 400 envelope at the compile face, so the two drivers
+// that carry no comparand-type policy of their own inherit one answer instead
+// of crashing (memory × BigInt) or letting the BSON encoder edit the query
+// (mongo × undefined → match-all). Why the rule lives at this face rather than
+// in each driver is argued in `./filter-comparand-type`.
 export * from './filter-comparand-type';
 // The comparand-SHAPE door (#5869, moved here by #9228) — the one
 // implementation of "a list operator takes a list" (`$in` / `$nin` need an