docs: restate the dissolved #5499 freeze prose on surviving grounds (#13196)

The maintainer lifted the #5499 investment freeze for driver-mongodb and
driver-memory on 2026-08-11 (recorded in the head note of
packages/spec/src/data/aggregation-conformance.ts), but ~13 in-code sites
still asserted it in the present tense, three of them as the REASON for a
structural choice.

Group A (present-tense claims): re-dated so each records what was true when
it was written, keeping the #5499 anchor.

Group B (three design rationales in packages/spec/src/data/): each rationale
survives losing the freeze premise and is restated on the surviving ground —
the #7956 divergence matrix and the #7872 / #8234 shared-face rulings. The
freeze is kept on record as the premise the argument was FIRST made from,
never silently deleted.

Group C (dated/historical records) is untouched, and so is
packages/spec/src/migrations/registry.ts, which is generated.

packages/runtime/src/datasource-autoconnect.test.ts asserted RETIREMENT, not
freeze, on the same anchor: re-anchored to #5704 / #6664, the mechanism that
actually owns it and that check:driver-memory-census enforces.

filter-logic-conformance.ts:179 is deliberately left alone: it is the table
cell for the behavioural divergence #13166 owns, and that card is undecided.

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

Author: os-trump

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
  *