From ed3229182f4c7c56ce16e5fee007ef32c98201c8 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Fri, 6 Nov 2026 02:13:24 +0000
Subject: [PATCH] fix(drill): the list URL says a boolean, $in/$nin, $ne and
 the text operators, so "Open in list" and "View all" open the exact list
 again

The object list route gains `filter[FIELD][bool]=true|false`, the
`[ne|contains|notcontains|startswith|endswith|icontains]` suffixes and the
repeated `[in]` / `[nin]` membership params. Each reads back through
parseUrlFilterTriples as the node convertFiltersToAST lowers the same
condition to, comparand type included, and exactRecordListFilter now proves
that per condition before it accepts one. A drill on a yes/no bucket or under
an $in / $ne / text-operator scope, and a related list's "View all" with such
a filter, get their list destination back; $or, $between, an empty set and a
boolean under $ne stay refused.

Claude-Session: https://claude.ai/code/session_01L6bhgW9yrPaVhdtD84RWcR
Co-authored-by: Claude <noreply@anthropic.com>
---
 .../30743-list-url-boolean-in-ne-text.md      |  16 ++
 ...bjectDataPage.filterChipI18n-9159.test.tsx |  34 +++
 ...bjectDataPage.saveAsViewFilterFold.test.ts |  31 ++-
 .../app-shell/src/views/ObjectDataPage.tsx    |  10 +-
 .../ObjectView.urlFilterSuffix-9196.test.ts   |  11 +-
 .../exactRecordListFilter-25888.test.ts       |  84 ++++++-
 .../src/views/drillUrlFilters.test.ts         | 131 +++++++++++
 .../app-shell/src/views/drillUrlFilters.ts    | 210 +++++++++++++++++-
 ...nRecordList.placeholderScope-9022.test.tsx |  27 ++-
 .../app-shell/src/views/useOpenRecordList.ts  |  88 ++++++--
 10 files changed, 609 insertions(+), 33 deletions(-)
 create mode 100644 .changeset/30743-list-url-boolean-in-ne-text.md

diff --git a/.changeset/30743-list-url-boolean-in-ne-text.md b/.changeset/30743-list-url-boolean-in-ne-text.md
new file mode 100644
index 00000000000..6b601b775a2
--- /dev/null
+++ b/.changeset/30743-list-url-boolean-in-ne-text.md
@@ -0,0 +1,16 @@
+---
+'@object-ui/app-shell': patch
+---
+
+fix(drill): "Open in list" and a related list's "View all" open the exact list again for a yes/no bucket, an `$in` / `$nin` set, `$ne` and the text operators
+
+Clause-②: yes (widening)
+Metadata-protocol: none
+
+The object list route (`/apps/APP/OBJECT/data?filter[...]`) gains six spellings, each read back as the very comparison the drill drawer queries, comparand type included:
+
+- `filter[FIELD][bool]=true|false` is equality to the boolean. `filter[FIELD]=true` still means the text "true".
+- `filter[FIELD][ne|contains|notcontains|startswith|endswith|icontains]=VALUE` is `$ne` and the five text operators.
+- `filter[FIELD][in]=A&filter[FIELD][in]=B` (and `[nin]`) is a set, one repeated param per member.
+
+A drill or "View all" whose filter uses only these and the earlier spellings now offers its list destination; anything the route still cannot say exactly (`$or`, `$between`, an empty set, a boolean under `$ne`) still offers none rather than a wider list. The list page shows each new condition as a chip with the filter builder's own operator label, removes it with the chip, and keeps it through "Save as view".
diff --git a/ui/packages/app-shell/src/views/ObjectDataPage.filterChipI18n-9159.test.tsx b/ui/packages/app-shell/src/views/ObjectDataPage.filterChipI18n-9159.test.tsx
index fbcf108b079..a40520ba331 100644
--- a/ui/packages/app-shell/src/views/ObjectDataPage.filterChipI18n-9159.test.tsx
+++ b/ui/packages/app-shell/src/views/ObjectDataPage.filterChipI18n-9159.test.tsx
@@ -256,3 +256,37 @@ describe('the is-empty filter chips are translated (objectui#11547)', () => {
     expect(packLabelOf('zh', EMPTY_FILTER.labelKey)).not.toBe(packLabelOf('zh', NULL_FILTER.labelKey));
   });
 });
+
+/**
+ * objectstack#30743 — a membership or negation chip draws its operator through
+ * the filter builder's label and its comparand verbatim, on the real page and
+ * the real packs: the label half translated, the comparand half not.
+ */
+describe('the membership and negation chips (objectstack#30743)', () => {
+  const packLabelOf = (language: string, key: string): unknown =>
+    key.split('.').reduce<unknown>(
+      (node, part) => (node as Record<string, unknown> | undefined)?.[part],
+      (builtInLocales as Record<string, unknown>)[language],
+    );
+
+  it.each([
+    ['in', 'filterBuilder.operators.in'],
+    ['nin', 'filterBuilder.operators.not_in'],
+  ])('`[%s]` renders the zh label of `%s` beside the members, joined', (suffix, key) => {
+    renderAt('zh', `filter[${FIELD}][${suffix}]=alice&filter[${FIELD}][${suffix}]=bob`);
+    expect(chipOperatorText()).toBe(`${packLabelOf('zh', key)} alice, bob`);
+  });
+
+  it('`[ne]` renders the zh "does not equal" label beside the comparand', () => {
+    renderAt('zh', `filter[${FIELD}][ne]=alice`);
+    const rendered = chipOperatorText();
+    expect(rendered).toBe(`${packLabelOf('zh', 'filterBuilder.operators.not_equals')} alice`);
+    expect(rendered).not.toContain('filterBuilder.operators');
+  });
+
+  it('CONTROL: the en pack differs, so the label half really went through `t`', () => {
+    renderAt('en', `filter[${FIELD}][in]=alice`);
+    expect(chipOperatorText()).toBe(`${packLabelOf('en', 'filterBuilder.operators.in')} alice`);
+    expect(packLabelOf('zh', 'filterBuilder.operators.in')).not.toBe(packLabelOf('en', 'filterBuilder.operators.in'));
+  });
+});
diff --git a/ui/packages/app-shell/src/views/ObjectDataPage.saveAsViewFilterFold.test.ts b/ui/packages/app-shell/src/views/ObjectDataPage.saveAsViewFilterFold.test.ts
index c5f27fb1a14..be3c227d73b 100644
--- a/ui/packages/app-shell/src/views/ObjectDataPage.saveAsViewFilterFold.test.ts
+++ b/ui/packages/app-shell/src/views/ObjectDataPage.saveAsViewFilterFold.test.ts
@@ -29,6 +29,8 @@ import {
   URL_FILTER_OPS,
   NULL_FILTER,
   EMPTY_FILTER,
+  URL_COMPARE_OPS,
+  URL_LIST_OPS,
   parseUrlFilterTriples,
   type FilterTriple,
 } from './drillUrlFilters';
@@ -103,7 +105,7 @@ describe('Save as view folds URL drill triples to spec rules (objectui#3419)', (
     // and the emptiness PAIR, whose one param carries a direction rather than a
     // comparand and so is not in that range map) so an operator added to the URL
     // contract fails HERE rather than at publish time. `parseUrlFilterTriples`
-    // emits nothing outside this set.
+    // emits nothing outside this set and the next test's (objectstack#30743).
     //
     // ⚠️ `NULL_FILTER.notOp` joined the set in objectui#9508. Listing only
     // `op` would have left this pin GREEN while the contract grew an operator
@@ -150,6 +152,33 @@ describe('Save as view folds URL drill triples to spec rules (objectui#3419)', (
     expect(gate.success).toBe(true);
   });
 
+  it('folds the negation, text, membership and boolean triples too (objectstack#30743)', () => {
+    // Computed from the two maps for the reason the test above gives: an
+    // operator added to either map fails here, not at publish time.
+    expect(Object.values(URL_COMPARE_OPS)).toEqual([
+      '!=', 'contains', 'notcontains', 'startswith', 'endswith', 'icontains',
+    ]);
+    expect(Object.values(URL_LIST_OPS)).toEqual(['in', 'nin']);
+    const triples: FilterTriple[] = [
+      ...Object.values(URL_COMPARE_OPS).map((op, i) => ['c' + i, op, 'v' + i] as FilterTriple),
+      ...Object.values(URL_LIST_OPS).map((op, i) => ['l' + i, op, ['a', 'b']] as FilterTriple),
+      ['done', '=', true],
+    ];
+    const { spec, gate } = saveAsView(triples);
+    expect(spec.filter).toEqual([
+      { field: 'c0', operator: 'not_equals', value: 'v0' },
+      { field: 'c1', operator: 'contains', value: 'v1' },
+      { field: 'c2', operator: 'not_contains', value: 'v2' },
+      { field: 'c3', operator: 'starts_with', value: 'v3' },
+      { field: 'c4', operator: 'ends_with', value: 'v4' },
+      { field: 'c5', operator: 'icontains', value: 'v5' },
+      { field: 'l0', operator: 'in', value: ['a', 'b'] },
+      { field: 'l1', operator: 'not_in', value: ['a', 'b'] },
+      { field: 'done', operator: 'equals', value: true },
+    ]);
+    expect(gate.success).toBe(true);
+  });
+
   it('keeps the is-NOT-null direction intact through the fold too (objectui#9508)', () => {
     // A drill that can be WRITTEN into the URL must also be savable, or the
     // user reads a chip the saved view then silently does not carry.
diff --git a/ui/packages/app-shell/src/views/ObjectDataPage.tsx b/ui/packages/app-shell/src/views/ObjectDataPage.tsx
index 0c59b6ddcf0..5e4bf913dd2 100644
--- a/ui/packages/app-shell/src/views/ObjectDataPage.tsx
+++ b/ui/packages/app-shell/src/views/ObjectDataPage.tsx
@@ -57,6 +57,7 @@ import {
   groupFilterChips,
   deleteFieldFilterParams,
   URL_FILTER_OPS,
+  URL_TRIPLE_OP_WORD,
   type FilterTriple,
 } from './drillUrlFilters.js';
 import {
@@ -147,6 +148,9 @@ const TRIPLE_OP_TO_SPEC_ALIAS: Record<string, string> = {
   ...Object.fromEntries(
     Object.entries(URL_FILTER_OPS).map(([suffix, symbol]) => [symbol, suffix]),
   ),
+  // objectstack#30743 — negation, text and membership triples carry their
+  // canonical word already, which `normalizeFilterOperator` returns unchanged.
+  ...URL_TRIPLE_OP_WORD,
 };
 
 /**
@@ -171,7 +175,7 @@ const TRIPLE_OP_TO_SPEC_ALIAS: Record<string, string> = {
  * from the persisted view with a debug-level note, never written off-spec:
  * declared = enforced, and a view body that fails the record gate is rejected
  * whole at publish time, which would lose the user's other conditions too.
- * (`parseUrlFilterTriples` only ever emits the five operators bridged above, so
+ * (`parseUrlFilterTriples` only ever emits operators bridged above, so
  * the drop path is defence in depth against the URL contract growing an
  * operator the spec has no word for.)
  */
@@ -675,7 +679,9 @@ export function ObjectDataPage({ dataSource, objects }: any) {
                 unwatched second English spelling that hides a pack miss
                 (objectui#3469 deleted exactly that pattern from this console).
               */}
-              <span className="text-muted-foreground">{textKey ? t(textKey) : text}</span>
+              <span className="text-muted-foreground">
+                {textKey && text !== undefined ? `${t(textKey)} ${text}` : textKey ? t(textKey) : text}
+              </span>
               <button
                 type="button"
                 onClick={() => removeUrlFilter(field)}
diff --git a/ui/packages/app-shell/src/views/ObjectView.urlFilterSuffix-9196.test.ts b/ui/packages/app-shell/src/views/ObjectView.urlFilterSuffix-9196.test.ts
index db835d2033f..e85f13f201d 100644
--- a/ui/packages/app-shell/src/views/ObjectView.urlFilterSuffix-9196.test.ts
+++ b/ui/packages/app-shell/src/views/ObjectView.urlFilterSuffix-9196.test.ts
@@ -78,7 +78,15 @@ const objectRoute = (qs: string) => parseUrlEqualityFilterTriples(new URLSearchP
 
 describe("objectui#9196 — the card's three rows, both readers, one run", () => {
   it('row 1 — an unknown operator suffix is dropped by BOTH readers', () => {
-    expect(dataSurface('filter[owners][contains]=u1')).toEqual([]);
+    // `[contains]` was this row's unknown suffix until objectstack#30743 gave
+    // the `/data` surface a text-operator spelling; `[like]` is still unknown
+    // to both.
+    expect(dataSurface('filter[owners][like]=u1')).toEqual([]);
+    expect(objectRoute('filter[owners][like]=u1')).toEqual([]);
+  });
+
+  it('row 1, after objectstack#30743 — `[contains]` executes on /data ONLY, and is dropped on the object route', () => {
+    expect(dataSurface('filter[owners][contains]=u1')).toEqual([['owners', 'contains', 'u1']]);
     expect(objectRoute('filter[owners][contains]=u1')).toEqual([]);
   });
 
@@ -160,6 +168,7 @@ describe('objectui#9196 — no emitted field name ever carries a bracket', () =>
     ]);
     expect(inputs.flatMap((qs) => dataSurface(qs))).toEqual([
       ['amount', '>=', '100'],
+      ['owners', 'contains', 'u1'],
       ['owners', '=', 'u1'],
       ['account.region', '=', 'NA'],
     ]);
diff --git a/ui/packages/app-shell/src/views/__tests__/exactRecordListFilter-25888.test.ts b/ui/packages/app-shell/src/views/__tests__/exactRecordListFilter-25888.test.ts
index c7ad6efb049..f198b74f52b 100644
--- a/ui/packages/app-shell/src/views/__tests__/exactRecordListFilter-25888.test.ts
+++ b/ui/packages/app-shell/src/views/__tests__/exactRecordListFilter-25888.test.ts
@@ -13,6 +13,7 @@
 import { describe, it, expect } from 'vitest';
 import { exactRecordListFilter, recordListPath } from '../useOpenRecordList';
 import { parseUrlFilterTriples } from '../drillUrlFilters';
+import { convertFiltersToAST } from '@object-ui/core';
 
 const readAll = () => true;
 const PARENT = { record_id: 'C-1' };
@@ -69,6 +70,78 @@ describe('exactRecordListFilter — the AND of the sources, written exactly or n
     ]);
   });
 
+  it('writes the spellings objectstack#30743 added: a boolean, a negation, the text operators, both sets', () => {
+    const filter = exactRecordListFilter(
+      [
+        PARENT,
+        [
+          ['done', '=', true],
+          ['archived', '=', false],
+          ['status', 'in', ['paid', 'sent']],
+          ['stage', 'nin', ['lost']],
+          ['owner', '!=', 'u1'],
+          ['name', 'contains', 'acme'],
+          ['name', 'notcontains', 'test'],
+          ['code', 'startswith', 'INV'],
+          ['code', 'endswith', '-X'],
+          ['email', 'icontains', 'ACME'],
+        ],
+      ],
+      readAll,
+    );
+    expect(roundTrip(filter)).toEqual([
+      ['record_id', '=', 'C-1'],
+      ['done', '=', true],
+      ['archived', '=', false],
+      ['status', 'in', ['paid', 'sent']],
+      ['stage', 'nin', ['lost']],
+      ['owner', '!=', 'u1'],
+      ['name', 'contains', 'acme'],
+      ['name', 'notcontains', 'test'],
+      ['code', 'startswith', 'INV'],
+      ['code', 'endswith', '-X'],
+      ['email', 'icontains', 'ACME'],
+    ]);
+  });
+
+  it('reads each of those back as the node the drill drawer queries, comparand type included', () => {
+    // The drawer lowers the drill's object filter through `convertFiltersToAST`;
+    // the list lowers nothing, it reads triples. The two must be one question.
+    const cases: Record<string, unknown>[] = [
+      { done: true },
+      { done: false },
+      { status: { $in: ['paid', 'sent'] } },
+      { stage: { $nin: ['lost'] } },
+      { owner: { $ne: 'u1' } },
+      { name: { $contains: 'acme' } },
+      { name: { $notContains: 'test' } },
+      { code: { $startsWith: 'INV' } },
+      { code: { $endsWith: '-X' } },
+      { email: { $icontains: 'ACME' } },
+    ];
+    for (const condition of cases) {
+      expect(roundTrip(exactRecordListFilter([condition], readAll))).toEqual([convertFiltersToAST(condition)]);
+    }
+  });
+
+  it('a set of numbers reads back as its members\' text, the posture equality and the bounds already have', () => {
+    expect(roundTrip(exactRecordListFilter([{ priority: { $in: [1, 2] } }], readAll))).toEqual([
+      ['priority', 'in', ['1', '2']],
+    ]);
+  });
+
+  it('a set and an equality on one field are two params, both kept', () => {
+    expect(roundTrip(exactRecordListFilter([{ status: { $in: ['a', 'b'] } }, { status: 'a' }], readAll))).toEqual([
+      ['status', 'in', ['a', 'b']],
+      ['status', '=', 'a'],
+    ]);
+  });
+
+  it('a repeated set that agrees is written once', () => {
+    const set = { status: { $in: ['a', 'b'] } };
+    expect(roundTrip(exactRecordListFilter([set, set], readAll))).toEqual([['status', 'in', ['a', 'b']]]);
+  });
+
   it('a repeated condition that agrees is written once', () => {
     const filter = exactRecordListFilter([PARENT, [['record_id', '=', 'C-1']]], readAll);
     expect(roundTrip(filter)).toEqual([['record_id', '=', 'C-1']]);
@@ -76,10 +149,13 @@ describe('exactRecordListFilter — the AND of the sources, written exactly or n
 
   it.each([
     ['an `or`', ['or', ['status', '=', 'a'], ['status', '=', 'b']]],
-    ['a set operator', [['status', 'in', ['a', 'b']]]],
-    ['a negation', [['status', '!=', 'a']]],
-    ['a text operator', [['name', 'contains', 'x']]],
-    ['a boolean comparand', [['done', '=', true]]],
+    ['an empty set', { status: { $in: [] } }],
+    ['a set holding an empty string', { status: { $in: ['a', ''] } }],
+    ['a set holding a boolean', { status: { $in: ['a', true] } }],
+    ['two different sets on one field', { $and: [{ status: { $in: ['a', 'b'] } }, { status: { $in: ['a'] } }] }],
+    ['a negation of a boolean', [['done', '!=', true]]],
+    ['a text operator with a number', { name: { $contains: 5 } }],
+    ['a `$between`', { amount: { $between: [1, 9] } }],
     ['an empty-string comparand', [['status', '=', '']]],
     ['a field-reference comparand', { amount: { $eq: { $field: 'budget' } } }],
     ['a second, different comparand for the relationship', [['record_id', '=', 'C-2']]],
diff --git a/ui/packages/app-shell/src/views/drillUrlFilters.test.ts b/ui/packages/app-shell/src/views/drillUrlFilters.test.ts
index bb0ebd24a86..b74c1f90032 100644
--- a/ui/packages/app-shell/src/views/drillUrlFilters.test.ts
+++ b/ui/packages/app-shell/src/views/drillUrlFilters.test.ts
@@ -12,6 +12,8 @@ import {
   parseUrlFilterTriples,
   parseUrlEqualityFilterTriples,
   URL_FILTER_OPS,
+  URL_COMPARE_OPS,
+  URL_LIST_OPS,
   serializeDrillFilterParams,
   deleteFieldFilterParams,
   groupFilterChips,
@@ -598,3 +600,132 @@ describe('the is-empty operator pair: `filter[<field>][empty]=true|false` (objec
     expect({ ...URL_FILTER_OPS }).toEqual({ gte: '>=', lte: '<=', gt: '>', lt: '<' });
   });
 });
+
+/**
+ * objectstack#30743 — a boolean comparand, `$ne`, the text operators and the
+ * two membership operators get a spelling. Each is pinned against the node
+ * `convertFiltersToAST` lowers the same condition to (what the drill drawer
+ * queries), so the list and the drawer ask one question.
+ */
+describe('the boolean, negation, text and membership spellings (objectstack#30743)', () => {
+  const written = (filter: Record<string, unknown>) =>
+    decodeURIComponent(serializeDrillFilterParams(filter).toString());
+  const roundTrip = (filter: Record<string, unknown>) =>
+    parseUrlFilterTriples(serializeDrillFilterParams(filter));
+
+  it('writes a boolean into the `[bool]` slot, not as equality text', () => {
+    expect(written({ is_active: true })).toBe('filter[is_active][bool]=true');
+    expect(written({ is_active: false })).toBe('filter[is_active][bool]=false');
+  });
+
+  it('reads the `[bool]` slot back as the BOOLEAN the drawer compares with', () => {
+    expect(roundTrip({ is_active: true })).toEqual([convertFiltersToAST({ is_active: true })]);
+    expect(roundTrip({ is_active: false })).toEqual([convertFiltersToAST({ is_active: false })]);
+    expect(parse('filter[is_active][bool]=true')).toEqual([['is_active', '=', true]]);
+  });
+
+  it('reads only the two boolean spellings in that slot; anything else is dropped, never text', () => {
+    for (const v of ['TRUE', '1', 'yes', 'True', 'false ']) {
+      expect(parse(`filter[is_active][bool]=${encodeURIComponent(v)}`)).toEqual([]);
+    }
+  });
+
+  it('CONTROL: `filter[field]=true` still means the string "true"', () => {
+    expect(parse('filter[name]=true')).toEqual([['name', '=', 'true']]);
+  });
+
+  it.each([
+    [{ status: { $ne: 'void' } }, 'filter[status][ne]=void'],
+    [{ name: { $contains: 'acme' } }, 'filter[name][contains]=acme'],
+    [{ name: { $notContains: 'acme' } }, 'filter[name][notcontains]=acme'],
+    [{ code: { $startsWith: 'INV' } }, 'filter[code][startswith]=INV'],
+    [{ code: { $endsWith: '-X' } }, 'filter[code][endswith]=-X'],
+    [{ email: { $icontains: 'ACME' } }, 'filter[email][icontains]=ACME'],
+  ])('writes %j as `%s` and reads it back as the drawer\'s node', (filter, url) => {
+    expect(written(filter)).toBe(url);
+    expect(roundTrip(filter)).toEqual([convertFiltersToAST(filter)]);
+  });
+
+  it('writes a set as one repeated param per member, read back as ONE triple in URL order', () => {
+    const filter = { status: { $in: ['paid', 'sent,partly'] } };
+    expect(written(filter)).toBe('filter[status][in]=paid&filter[status][in]=sent,partly');
+    expect(roundTrip(filter)).toEqual([convertFiltersToAST(filter)]);
+    const not = { stage: { $nin: ['lost', 'void'] } };
+    expect(roundTrip(not)).toEqual([convertFiltersToAST(not)]);
+  });
+
+  it('keeps a set where its first member sat among the other conditions', () => {
+    expect(parse('filter[status][in]=a&filter[region]=west&filter[status][in]=b')).toEqual([
+      ['status', 'in', ['a', 'b']],
+      ['region', '=', 'west'],
+    ]);
+  });
+
+  it('keeps `in` and `nin` on one field as two triples, and two fields as two sets', () => {
+    expect(parse('filter[s][in]=a&filter[s][nin]=b&filter[t][in]=c&filter[s][in]=d')).toEqual([
+      ['s', 'in', ['a', 'd']],
+      ['s', 'nin', ['b']],
+      ['t', 'in', ['c']],
+    ]);
+  });
+
+  it('writes the whole set or nothing: an empty set, an empty member or a boolean member writes no param', () => {
+    expect(written({ status: { $in: [] } })).toBe('');
+    expect(written({ status: { $in: ['a', ''] } })).toBe('');
+    expect(written({ status: { $in: ['a', true] } })).toBe('');
+  });
+
+  it('a later source REPLACES an earlier set on the same field, as every other param does', () => {
+    expect(written({ $and: [{ status: { $in: ['a', 'b'] } }, { status: { $in: ['c'] } }] })).toBe(
+      'filter[status][in]=c',
+    );
+  });
+
+  it('writes nothing for a `$ne` the route would read back as text (a boolean)', () => {
+    expect(written({ is_active: { $ne: true } })).toBe('');
+  });
+
+  it('the new lookups have no prototype either: an inherited member is not a suffix', () => {
+    for (const name of Object.getOwnPropertyNames(Object.prototype)) {
+      expect(parse(`filter[amount][${name}]=1`)).toEqual([]);
+    }
+    expect(Object.getPrototypeOf(URL_COMPARE_OPS)).toBeNull();
+    expect(Object.getPrototypeOf(URL_LIST_OPS)).toBeNull();
+  });
+
+  it('renders the operator label beside the comparand; a set joins its members', () => {
+    expect(
+      groupFilterChips([
+        ['status', 'in', ['paid', 'sent']],
+        ['stage', 'nin', ['lost']],
+        ['owner', '!=', 'u1'],
+        ['name', 'contains', 'acme'],
+        ['is_active', '=', true],
+      ]),
+    ).toEqual([
+      { field: 'status', textKey: 'filterBuilder.operators.in', text: 'paid, sent' },
+      { field: 'stage', textKey: 'filterBuilder.operators.not_in', text: 'lost' },
+      { field: 'owner', textKey: 'filterBuilder.operators.not_equals', text: 'u1' },
+      { field: 'name', textKey: 'filterBuilder.operators.contains', text: 'acme' },
+      { field: 'is_active', text: '= true' },
+    ]);
+  });
+
+  it('removing the chip clears every member of a set with the same prefix delete', () => {
+    const params = new URLSearchParams('filter[status][in]=a&filter[status][in]=b&filter[stage]=won');
+    deleteFieldFilterParams(params, 'status');
+    expect(params.toString()).toBe('filter%5Bstage%5D=won');
+  });
+
+  it('CONTROL: the equality-only route still executes none of the new suffixes', () => {
+    expect(
+      parseUrlEqualityFilterTriples(
+        new URLSearchParams('filter[a][bool]=true&filter[b][in]=x&filter[c][ne]=y&filter[d][contains]=z'),
+      ),
+    ).toEqual([]);
+  });
+
+  it('CONTROL: the range vocabulary did not grow', () => {
+    expect({ ...URL_FILTER_OPS }).toEqual({ gte: '>=', lte: '<=', gt: '>', lt: '<' });
+  });
+});
diff --git a/ui/packages/app-shell/src/views/drillUrlFilters.ts b/ui/packages/app-shell/src/views/drillUrlFilters.ts
index 67a9fe4374b..35873c7f454 100644
--- a/ui/packages/app-shell/src/views/drillUrlFilters.ts
+++ b/ui/packages/app-shell/src/views/drillUrlFilters.ts
@@ -20,11 +20,22 @@
  *                                                     / `[field, 'is_not_null', true]`
  *   - is empty      `filter[field][empty]=true|false`  → `[field, 'is_empty', true]`
  *                                                     / `[field, 'is_not_empty', true]`
+ *   - boolean       `filter[field][bool]=true|false`   → `[field, '=', true | false]`
+ *   - negation / text `filter[field][ne|contains|notcontains|startswith|endswith|icontains]=v`
+ *                                                     → `[field, '!=' | 'contains' | … , v]`
+ *   - membership    `filter[field][in|nin]=a&filter[field][in|nin]=b`
+ *                                                     → `[field, 'in' | 'nin', ['a', 'b']]`
  * A date-bucket drill emits `gte` + `lt` to scope a list to a time bucket; an
  * EMPTY-bucket drill emits `[null]=true` (objectui#9159), a widget filter
  * asking for "this field is set" emits `[null]=false` (objectui#9508), and a
  * widget filter saying "is empty" / "is not empty" emits `[empty]=true|false`
- * (objectui#11547).
+ * (objectui#11547). A boolean bucket emits `[bool]`, and a measure scope or a
+ * widget filter using `$in`, `$nin`, `$ne` or a text operator emits its own
+ * suffix (objectstack#30743).
+ *
+ * The triple each of the last three rows reads back is the node
+ * `convertFiltersToAST` lowers the same condition to, operator AND comparand
+ * type, so the list asks the server the question the drill drawer asked.
  */
 
 /** Filter triple shape shared with view metadata: [field, operator, value]. */
@@ -233,6 +244,105 @@ export const EMPTY_FILTER = {
   notLabelKey: 'filterBuilder.operators.is_not_empty',
 } as const;
 
+/**
+ * A BOOLEAN comparand (objectstack#30743): what a drill on a yes/no bucket
+ * carries, `{ is_active: true }`.
+ *
+ * ## Why it is its own param and not `filter[field]=true`
+ *
+ * The route carries text, so the equality arm reads `filter[is_active]=true`
+ * back as the STRING `'true'`: `[is_active, '=', 'true']`, a different
+ * comparison from the drawer's `[is_active, '=', true]` (measured). That arm
+ * cannot learn to read `'true'` as a boolean either, because a text field may
+ * hold the word "true" and `filter[name]=true` has always meant that string.
+ * So a boolean gets a slot whose only two spellings are the two booleans,
+ * {@link NULL_FILTER}'s posture: anything else in it is dropped like an
+ * unknown suffix, never read as a string.
+ *
+ * Unlike that pair, the value here IS the comparand, so the triple's operator
+ * is plain equality and the comparand is the boolean itself.
+ */
+export const BOOLEAN_FILTER = {
+  /** URL param suffix: `filter[<field>][bool]`. */
+  param: 'bool',
+  /** The ONLY param value that reads back as `true`. */
+  flag: 'true',
+  /** The ONLY param value that reads back as `false`. */
+  notFlag: 'false',
+} as const;
+
+/**
+ * Operators whose param carries ONE text comparand beside the range bounds
+ * (objectstack#30743): URL suffix → the ObjectQL AST operator the triple
+ * carries, which is exactly what `convertFiltersToAST` lowers the matching
+ * producer key in {@link COMPARE_OP_PARAM} to.
+ *
+ * ⚠️ Kept OUT of {@link URL_FILTER_OPS}: that map's key list is pinned
+ * (`drillEmptyBucketNavHost-9085.test.ts`) and it is the RANGE vocabulary a
+ * date bucket reads. Prototype-free for the reason that map gives: the suffix
+ * comes from the address bar.
+ */
+export const URL_COMPARE_OPS: Record<string, string> = Object.assign(Object.create(null), {
+  ne: '!=',
+  contains: 'contains',
+  notcontains: 'notcontains',
+  startswith: 'startswith',
+  endswith: 'endswith',
+  icontains: 'icontains',
+});
+
+/** ObjectQL producer key → URL param suffix (WRITE side) for {@link URL_COMPARE_OPS}. */
+export const COMPARE_OP_PARAM: Record<string, string> = {
+  $ne: 'ne',
+  $contains: 'contains',
+  $notContains: 'notcontains',
+  $startsWith: 'startswith',
+  $endsWith: 'endswith',
+  $icontains: 'icontains',
+};
+
+/**
+ * Membership operators (objectstack#30743): URL suffix → AST operator. The
+ * param is REPEATED, one member per occurrence, and the read side gathers
+ * every occurrence on one field into ONE triple whose comparand is the list:
+ * `filter[status][in]=paid&filter[status][in]=sent` → `[status, 'in',
+ * ['paid', 'sent']]`. Repetition rather than a delimiter, because no
+ * character is safe to reserve inside a member: a status may well contain a
+ * comma.
+ */
+export const URL_LIST_OPS: Record<string, string> = Object.assign(Object.create(null), {
+  in: 'in',
+  nin: 'nin',
+});
+
+/** ObjectQL producer key → URL param suffix (WRITE side) for {@link URL_LIST_OPS}. */
+export const LIST_OP_PARAM: Record<string, string> = { $in: 'in', $nin: 'nin' };
+
+/**
+ * The canonical `ViewFilterRule` operator word for each AST operator the two
+ * maps above read back (objectstack#30743). Two readers, one table:
+ *
+ *   - the chip's operator label is `filterBuilder.operators.<word>`, the filter
+ *     builder's existing keys, present and translated in all ten packs;
+ *   - "Save as view" folds a triple to a spec rule through this word, so the
+ *     saved view keeps the condition the list showed.
+ */
+export const URL_TRIPLE_OP_WORD: Record<string, string> = Object.assign(Object.create(null), {
+  '!=': 'not_equals',
+  contains: 'contains',
+  notcontains: 'not_contains',
+  startswith: 'starts_with',
+  endswith: 'ends_with',
+  icontains: 'icontains',
+  in: 'in',
+  nin: 'not_in',
+});
+
+/** A comparand the route can carry as one param value and read back as itself, up to text. */
+function isUrlComparand(v: unknown): v is string | number {
+  return (typeof v === 'string' && v !== '') || (typeof v === 'number' && Number.isFinite(v));
+}
+
 /**
  * The ONE grammar for a key in this family, so the two arms below cannot drift
  * apart on what a field name is: `filter[<field>]`, with an OPTIONAL
@@ -250,9 +360,17 @@ const FILTER_KEY = /^filter\[([^[\]]+)\](?:\[([^[\]]+)\])?$/;
  * EMPTY_FILTER}, the is-empty pair) search params into ObjectQL triples. An
  * unknown operator suffix is ignored (never silently downgraded to equality),
  * and so is an unknown value in either flag slot.
+ *
+ * `filter[<field>][bool]=true|false` ({@link BOOLEAN_FILTER}), the negation
+ * and text suffixes ({@link URL_COMPARE_OPS}) and the repeated membership
+ * suffixes ({@link URL_LIST_OPS}) are read too (objectstack#30743). A
+ * membership triple sits where its FIRST occurrence sat, holding every
+ * occurrence's value in URL order.
  */
 export function parseUrlFilterTriples(searchParams: URLSearchParams): FilterTriple[] {
   const out: FilterTriple[] = [];
+  /** `field` + suffix → the members of that membership triple, so repeats join it. */
+  const lists = new Map<string, unknown[]>();
   searchParams.forEach((value, key) => {
     if (value === '') return;
     const m = FILTER_KEY.exec(key);
@@ -278,7 +396,28 @@ export function parseUrlFilterTriples(searchParams: URLSearchParams): FilterTrip
       else if (value === EMPTY_FILTER.notFlag) out.push([field, EMPTY_FILTER.notOp, true]);
       return;
     }
-    const op = URL_FILTER_OPS[suffix];
+    if (suffix === BOOLEAN_FILTER.param) {
+      // objectstack#30743 — the value IS the comparand, and only the two
+      // boolean spellings are one; anything else is dropped, never read as text.
+      if (value === BOOLEAN_FILTER.flag) out.push([field, '=', true]);
+      else if (value === BOOLEAN_FILTER.notFlag) out.push([field, '=', false]);
+      return;
+    }
+    const listOp = URL_LIST_OPS[suffix];
+    if (listOp) {
+      // objectstack#30743 — one member per occurrence, gathered into one triple.
+      // The key cannot collide across fields: a field name excludes `]`.
+      const slot = `${field}]${suffix}`;
+      const members = lists.get(slot);
+      if (members) members.push(value);
+      else {
+        const fresh: unknown[] = [value];
+        lists.set(slot, fresh);
+        out.push([field, listOp, fresh]);
+      }
+      return;
+    }
+    const op = URL_FILTER_OPS[suffix] ?? URL_COMPARE_OPS[suffix];
     if (op) out.push([field, op, value]);
   });
   return out;
@@ -326,7 +465,10 @@ export function parseUrlEqualityFilterTriples(searchParams: URLSearchParams): Fi
  * and `{ $exists: true }` (objectui#9508) — becomes `filter[field][null]` with
  * the direction as its value; `{ $empty: true | false }` ({@link EMPTY_FILTER},
  * objectui#11547) becomes `filter[field][empty]` the same way; a plain value
- * becomes `filter[field]`.
+ * becomes `filter[field]`. A boolean value becomes `filter[field][bool]`
+ * ({@link BOOLEAN_FILTER}); `$ne` and the text operators ({@link
+ * COMPARE_OP_PARAM}) become their own suffix; `$in` / `$nin` ({@link
+ * LIST_OP_PARAM}) become one repeated param per member (objectstack#30743).
  * `null`/`undefined` values and objects with no recognized operator are skipped
  * (drill degrades to a superset) rather than stringified to
  * `"[object Object]"`.
@@ -428,11 +570,40 @@ function collectFilterParams(filter: Record<string, unknown>, params: URLSearchP
         const bound = ops[op];
         if (bound != null) params.set(`filter[${field}][${suffix}]`, String(bound));
       }
-      continue; // handled (flag / range ops) or skipped — never String(object)
+      // objectstack#30743 — negation and the text operators: one comparand
+      // each, written only when it is one the route reads back as itself (a
+      // boolean `$ne` would read back as a string, so it writes nothing).
+      for (const [op, suffix] of Object.entries(COMPARE_OP_PARAM)) {
+        const comparand = ops[op];
+        if (isUrlComparand(comparand)) params.set(`filter[${field}][${suffix}]`, String(comparand));
+      }
+      // objectstack#30743 — membership, one repeated param per member. The
+      // whole list or nothing: a member the route cannot carry (or an empty
+      // list, which no param can say) skips the condition, because writing the
+      // rest would change the set. A later source REPLACES an earlier one's
+      // list on the same field, the `set` posture of every other param here.
+      for (const [op, suffix] of Object.entries(LIST_OP_PARAM)) {
+        const members = ops[op];
+        if (!Array.isArray(members) || members.length === 0 || !members.every(isUrlComparand)) continue;
+        const name = `filter[${field}][${suffix}]`;
+        params.delete(name);
+        for (const member of members) params.append(name, String(member));
+      }
+      continue; // handled (flag / range / compare / list ops) or skipped — never String(object)
     }
-    // Arrays reach here as `$in`-style comparands this dialect cannot spell;
-    // skipping keeps the promise above (never `String(array)`).
+    // A bare array is not membership (`convertFiltersToAST` refuses it), and
+    // `$in` arrives as an operator object above; skipping keeps the promise
+    // above (never `String(array)`).
     if (Array.isArray(value)) continue;
+    if (typeof value === 'boolean') {
+      // objectstack#30743 — `filter[field]=true` reads back as the STRING
+      // 'true'; the boolean slot reads back as the boolean.
+      params.set(
+        `filter[${field}][${BOOLEAN_FILTER.param}]`,
+        value ? BOOLEAN_FILTER.flag : BOOLEAN_FILTER.notFlag,
+      );
+      continue;
+    }
     params.set(`filter[${field}]`, String(value));
   }
 }
@@ -469,7 +640,13 @@ export interface FilterChip {
   field: string;
   /** Finished, language-neutral text (a comparand, a pair of range bounds). */
   text?: string;
-  /** i18n key whose translation IS this chip's text. Mutually exclusive with `text`. */
+  /**
+   * i18n key whose translation is this chip's operator PROSE. Alone, it IS the
+   * chip's text (the emptiness pairs, which take no comparand). Beside `text`,
+   * it is the operator label drawn before the comparand: a negation, text or
+   * membership chip (objectstack#30743), whose operator is prose and whose
+   * comparand is still the user's own.
+   */
   textKey?: string;
 }
 
@@ -492,7 +669,11 @@ export interface FilterChip {
  * The "is empty" pair ({@link EMPTY_FILTER}, objectui#11547) gets the same two
  * arms, checked after these.
  *
- * These arms are the only ones that yield `textKey` rather than `text`, for the
+ * A negation, text or membership triple (objectstack#30743) yields BOTH: the
+ * operator's label as `textKey` and its comparand as `text`, the members of a
+ * list joined with a comma.
+ *
+ * The emptiness arms are the only ones that yield `textKey` rather than `text`, for the
  * reason on {@link FilterChip}. The keys are the filter builder's existing
  * operator keys, already present and already translated in all ten packs, and
  * already policed by that family's locale-parity pin — ⛔ not strings forked for
@@ -529,6 +710,19 @@ export function groupFilterChips(triples: FilterTriple[]): FilterChip[] {
     }
     const gte = list.find(([, op]) => op === '>=' || op === '>');
     const lt = list.find(([, op]) => op === '<' || op === '<=');
+    // objectstack#30743 — a negation, text or membership operator is prose,
+    // drawn through the filter builder's own label beside the user's comparand.
+    // After the range arm's inputs are read, so a field that also carries a
+    // range bound keeps the range chip it had.
+    const word = gte || lt ? undefined : URL_TRIPLE_OP_WORD[String(list[0][1])];
+    if (word) {
+      const comparand = list[0][2];
+      return {
+        field,
+        textKey: `filterBuilder.operators.${word}`,
+        text: Array.isArray(comparand) ? comparand.map(String).join(', ') : String(comparand),
+      };
+    }
     const text =
       gte || lt
         ? `${gte ? String(gte[2]) : '…'} → ${lt ? String(lt[2]) : '…'}`
diff --git a/ui/packages/app-shell/src/views/useOpenRecordList.placeholderScope-9022.test.tsx b/ui/packages/app-shell/src/views/useOpenRecordList.placeholderScope-9022.test.tsx
index 6c1d01bc46f..df5fccf3718 100644
--- a/ui/packages/app-shell/src/views/useOpenRecordList.placeholderScope-9022.test.tsx
+++ b/ui/packages/app-shell/src/views/useOpenRecordList.placeholderScope-9022.test.tsx
@@ -182,7 +182,8 @@ describe('useOpenRecordList — the drilled URL carries the RESOLVED scope (obje
  * list route can say the drill filter EXACTLY.
  *
  * A drill filter is the bucket AND the widget's filter AND the measure's drill
- * scope. The route's grammar holds one value per param and has no `$in`, so
+ * scope. The route's grammar holds one value per param and had no `$in` until
+ * objectstack#30743, so
  * writing such a filter through the bare encoder kept the later of two
  * conditions on one field (or skipped the `$in`) and opened a WIDER list than
  * the drawer: the app-showcase "Paid Rate by Status" Sent bar's Paid Invoices
@@ -218,10 +219,32 @@ describe('useRecordListDrillNavigation — only an exact list destination is off
     expect(result.current.url).toBe(START);
   });
 
-  it('an $in scope offers no destination', () => {
+  it('an $in scope opens exactly that set since objectstack#30743, one repeated param per member', () => {
     const { result } = harness();
     const drill = composeDrillFilter({ status: { $in: ['paid', 'sent'] } }, { region: 'west' });
 
+    expect(result.current.canOpenRecordList('invoice', drill)).toBe(true);
+    act(() => result.current.openRecordList('invoice', drill));
+    expect(result.current.url).toBe(
+      '/apps/crm/invoice/data?filter%5Bstatus%5D%5Bin%5D=paid&filter%5Bstatus%5D%5Bin%5D=sent&filter%5Bregion%5D=west',
+    );
+  });
+
+  it('a bucket on a yes/no field opens the list with a BOOLEAN comparand (objectstack#30743)', () => {
+    const { result } = harness();
+    const drill = composeDrillFilter({ status: 'paid' }, { is_overdue: false });
+
+    expect(result.current.canOpenRecordList('invoice', drill)).toBe(true);
+    act(() => result.current.openRecordList('invoice', drill));
+    expect(result.current.url).toBe(
+      '/apps/crm/invoice/data?filter%5Bstatus%5D=paid&filter%5Bis_overdue%5D%5Bbool%5D=false',
+    );
+  });
+
+  it('a `$ne` on a boolean still offers no destination: the route would read it back as text', () => {
+    const { result } = harness();
+    const drill = composeDrillFilter({ is_overdue: { $ne: true } }, { region: 'west' });
+
     expect(result.current.canOpenRecordList('invoice', drill)).toBe(false);
     act(() => result.current.openRecordList('invoice', drill));
     expect(result.current.url).toBe(START);
diff --git a/ui/packages/app-shell/src/views/useOpenRecordList.ts b/ui/packages/app-shell/src/views/useOpenRecordList.ts
index 5c5bd7c0973..3302a7ee1f2 100644
--- a/ui/packages/app-shell/src/views/useOpenRecordList.ts
+++ b/ui/packages/app-shell/src/views/useOpenRecordList.ts
@@ -8,11 +8,23 @@
 
 import { useCallback, useMemo } from 'react';
 import { useNavigate, useParams } from 'react-router-dom';
-import { resolveFilterPlaceholders, toFilterNodeSafely, type FilterTokenScope } from '@object-ui/core';
+import {
+  convertFiltersToAST,
+  resolveFilterPlaceholders,
+  toFilterNodeSafely,
+  type FilterTokenScope,
+} from '@object-ui/core';
 import { useFilterScope } from '@object-ui/react';
 import { usePermissions } from '@object-ui/permissions';
 import { parseFilterAST } from '@objectstack/spec/data';
-import { parseUrlFilterTriples, RANGE_OP_PARAM, serializeDrillFilterParams } from './drillUrlFilters.js';
+import {
+  COMPARE_OP_PARAM,
+  LIST_OP_PARAM,
+  parseUrlFilterTriples,
+  RANGE_OP_PARAM,
+  serializeDrillFilterParams,
+  type FilterTriple,
+} from './drillUrlFilters.js';
 
 /**
  * The router path of an object's ADR-0055 bare data surface, scoped by
@@ -60,22 +72,34 @@ export function recordListPath(
  * route's grammar and nothing else:
  *
  *   - equality to a non-empty string or a finite number, `filter[FIELD]=VALUE`;
+ *   - equality to a boolean, `filter[FIELD][bool]=true|false` (objectstack#30743);
  *   - the four range bounds `$gte` / `$lte` / `$gt` / `$lt`, same comparands;
+ *   - `$ne`, same comparands, and the text operators `$contains` /
+ *     `$notContains` / `$startsWith` / `$endsWith` / `$icontains` with a
+ *     non-empty string (objectstack#30743);
+ *   - `$in` / `$nin` with a non-empty list of those comparands, one repeated
+ *     param per member (objectstack#30743);
  *   - the is-null pair (`$null`, or `$exists` inverted) and `$empty`, each
  *     with a boolean;
  *   - conjunction, which the route spells by writing several params.
  *
- * Everything else answers `null`: `$or` and every other combinator, `$in`,
- * `$ne`, the text operators, a boolean, `null` or `Date` comparand (the route
- * carries text, and those round-trips are not the list's own comparison), an
- * empty string (the read side skips an empty param), two different comparands
- * in one param (one key holds one value), a filter the lowering refuses, and a
- * condition on a field `canRead` denies (`ObjectDataPage` drops a condition on
- * an unreadable field and would open the list without it).
+ * Everything else answers `null`: `$or` and every other combinator,
+ * `$between`, a `null` or `Date` comparand and a boolean under any operator
+ * but equality (the route carries text, and those round-trips are not the
+ * list's own comparison), an empty string or an empty list (the read side
+ * skips an empty param, and no param says "none of these"), two different
+ * comparands in one param (one key holds one value, one list), a filter the
+ * lowering refuses, and a condition on a field `canRead` denies
+ * (`ObjectDataPage` drops a condition on an unreadable field and would open
+ * the list without it).
  *
  * Every condition is also proved by its own round trip before it is accepted:
  * written alone, it must read back through `parseUrlFilterTriples` (what
- * `ObjectDataPage` parses) as exactly one triple.
+ * `ObjectDataPage` parses) as exactly one triple, and that triple must be the
+ * node `convertFiltersToAST` lowers the condition to (what the drill drawer
+ * queries), operator and comparand type included. The one difference allowed
+ * is a finite number reading back as its own text, which the equality and
+ * range spellings have always carried.
  */
 export function exactRecordListFilter(
   sources: readonly unknown[],
@@ -88,12 +112,19 @@ export function exactRecordListFilter(
   const isComparand = (v: unknown): v is string | number =>
     (typeof v === 'string' && v !== '') || (typeof v === 'number' && Number.isFinite(v));
 
+  const isText = (v: unknown): v is string => typeof v === 'string' && v !== '';
+
   const add = (field: string, condition: Record<string, unknown>): boolean => {
     if (!canRead(field)) return false;
     const params = serializeDrillFilterParams(condition);
     const entries = Array.from(params.entries());
-    if (entries.length !== 1 || parseUrlFilterTriples(params).length !== 1) return false;
-    const [name, value] = entries[0];
+    // One param name: a membership condition repeats it, once per member.
+    const names = new Set(entries.map(([name]) => name));
+    const triples = parseUrlFilterTriples(params);
+    if (names.size !== 1 || triples.length !== 1) return false;
+    if (!isSameComparison(triples[0], convertFiltersToAST(condition))) return false;
+    const [name] = names;
+    const value = JSON.stringify(entries.map(([, v]) => v));
     const prior = written.get(name);
     if (prior !== undefined) return prior === value;
     written.set(name, value);
@@ -109,15 +140,18 @@ export function exactRecordListFilter(
         continue;
       }
       if (key.startsWith('$')) return false;
-      if (isComparand(value)) {
+      if (isComparand(value) || typeof value === 'boolean') {
         if (!add(key, { [key]: value })) return false;
         continue;
       }
       if (!isPlainObject(value)) return false;
       for (const [op, operand] of Object.entries(value)) {
         let ok: boolean;
-        if (op === '$eq' && isComparand(operand)) ok = add(key, { [key]: operand });
+        if (op === '$eq' && (isComparand(operand) || typeof operand === 'boolean')) ok = add(key, { [key]: operand });
         else if (Object.prototype.hasOwnProperty.call(RANGE_OP_PARAM, op) && isComparand(operand)) ok = add(key, { [key]: { [op]: operand } });
+        else if (op === '$ne' && isComparand(operand)) ok = add(key, { [key]: { [op]: operand } });
+        else if (op !== '$ne' && Object.prototype.hasOwnProperty.call(COMPARE_OP_PARAM, op) && isText(operand)) ok = add(key, { [key]: { [op]: operand } });
+        else if (Object.prototype.hasOwnProperty.call(LIST_OP_PARAM, op) && Array.isArray(operand) && operand.length > 0 && operand.every(isComparand)) ok = add(key, { [key]: { [op]: operand } });
         else if ((op === '$null' || op === '$empty') && typeof operand === 'boolean') ok = add(key, { [key]: { [op]: operand } });
         else if (op === '$exists' && typeof operand === 'boolean') ok = add(key, { [key]: { $null: !operand } });
         else ok = false;
@@ -145,6 +179,30 @@ export function exactRecordListFilter(
   return { $and: conditions };
 }
 
+/**
+ * Whether the triple the list route read back is the comparison the drill
+ * lowers to: same field, same operator, same comparand. The one difference
+ * allowed is a finite number reading back as its own text (`10` as `'10'`),
+ * what the route has always carried for equality and the range bounds; a
+ * boolean reading back as `'true'` is a different comparison and fails here.
+ */
+function isSameComparison(read: FilterTriple, lowered: unknown): boolean {
+  if (!Array.isArray(lowered) || lowered.length !== 3) return false;
+  const [field, op, comparand] = lowered as unknown[];
+  if (read[0] !== field || read[1] !== op) return false;
+  const same = (a: unknown, b: unknown) =>
+    a === b || (typeof b === 'number' && Number.isFinite(b) && a === String(b));
+  if (Array.isArray(comparand)) {
+    const members = read[2];
+    return (
+      Array.isArray(members) &&
+      members.length === comparand.length &&
+      members.every((m, i) => same(m, comparand[i]))
+    );
+  }
+  return same(read[2], comparand);
+}
+
 function isPlainObject(value: unknown): value is Record<string, unknown> {
   if (value === null || typeof value !== 'object' || Array.isArray(value)) return false;
   const proto = Object.getPrototypeOf(value);
@@ -159,7 +217,7 @@ function isPlainObject(value: unknown): value is Record<string, unknown> {
  * promises the list behind the number the user clicked: the bucket AND the
  * widget's filter AND the measure's drill scope, all composed into `filter`.
  * `serializeDrillFilterParams` alone keeps the later of two conditions on one
- * param and skips an `$in` / `$nin` comparand, which writes a WIDER list than
+ * param and skips what it cannot spell, which writes a WIDER list than
  * the drawer shows (a `status = sent` bucket under a `status = paid` measure
  * scope lists every sent invoice instead of none). So the destination is
  * offered only through {@link exactRecordListFilter}, the rule a related list's