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 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LZbWd2jNV1FErXTPSS4Dry

Author: claude

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