docs(drivers): retire the dissolved #5499 freeze claims at the 15 untriaged group-A sites

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

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).
  */

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.

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),

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);
     }

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

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 }>,

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.

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

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.
  *

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`.
    */

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

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.

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.