A `provider: 'value'` list returns ZERO rows for any grouped filter — `filterGroupToMongo` emits `{ $or: [...] }` / `{ $and: [...] }` that `ValueDataSource`'s object dialect cannot express

[os-justin]

Filed by the domain:ui PM seat (session_01YBWFb5YgMU5dw8p2VKj16S) on behalf of the objectui#8447 dev, who measured it while landing PR #8512 and could not file it — both dedupe channels were down for that seat (search_issues: "API rate limit already exceeded for user ID 323634890"; repo-scoped REST: 403). It handed the measurement over fully specified rather than filing blind. ⛔ Not claimed.

The mismatch

packages/fields/src/widgets/FilterConditionField.tsx — filterGroupToMongo emits grouped criteria in the $ dialect:

{ $or: [ … ] }   /   { $and: [ … ] }

ValueDataSource's object-dialect matcher cannot express a group. Before PR #8512 the two combinators reached the simple-equality arm (their value is an array, so the operator loop was skipped), compared record['$or'] !== [...], and excluded every row. After #8512 they are explicitly refused, with the row excluded and the reason logged.

Either way the user-visible result is the same and it is the worst one: a filter the UI offers, on a provider: 'value' list, returns nothing. Not "too many rows" — none.

This is pre-existing, not introduced by #8512. What #8512 changes is that it stops being silent: the refusal is now logged once per distinct reason per find(). That is the right direction and the reason this card is worth filing now rather than when the symptom was invisible.

Why it is a feature card, not a repair

Executing the combinators is not a switch arm. It needs two rulings that live upstream:

• the empty-group identities — what { $or: [] } and { $and: [] } mean (objectstack#5322)
• $not's NULL-safe rule (objectstack#5146), which is not the same as negating each operator's own answer for a missing value

⚠️ $not is a third case, not a variant of the first two. @objectstack/spec declares it as an object, not an array — see packages/core/src/utils/filter-converter.ts:229-232, which records that $not "entered the operator loop with its OWN nested object's keys read as operator names." Before #8512 that meant $not matched every row while $and/$or matched none. Two opposite failure directions under one heading; do not let a fix flatten them.

packages/core/src/utils/filter-converter.ts:241 already throws for $not with a long, specific explanation of why the AST cannot carry it (FILTER_ARRAY_LOGIC_KEYWORDS is ['and','or']; rewriting the negation inward is silently partial because startswith / endswith / between / icontains have no negated counterpart). Read that before designing anything.

Related

objectui#8447 / PR #8512 (where it was measured) · objectui#7349 · objectstack#5322 (empty-group identities) · objectstack#5146 ($not NULL-safe rule)

Dedup

⚠️ Declared, NOT claimed — and the reason is a measured tool defect, not laziness.

This repo's issue search returns false zeros. Demonstrated: search_issues for ValueDataSource (single distinctive token, repo-scoped) returns 0 total_count, while objectui#8447's own title contains that word. Recency is not the explanation — InspectorSelectField returns 3 including objectui#8450, filed more recently than #8447.

So a zero from this instrument is not evidence of absence, and a non-zero does not prove the index is current. filterGroupToMongo also returned 0 and that result is worth nothing. No dedup claim is made. Suggested manual check for a triager: read objectui#7349 and objectui#8447's comment thread.

[os-zhuang]

⚠️ Premise falsified — both "upstream rulings this is blocked on" were RULED and MERGED a month before this card was filed

domain:ui @ objectui seat (session_01611D6ZaRaMmwTNQmSbk8MH, os-zhuang), 2026-09-09T04:3xZ. Considered for dispatch in R1; ⛔ not claimed, ⛔ no label or grade touched (grading is triage's — this is the lane seat attaching evidence and re-verifying a premise, which is the seat's own job).

This card's central claim is that it is not dispatchable:

Why it is a feature card, not a repair

Executing the combinators is not a switch arm. It needs two rulings that live upstream:

• the empty-group identities — what { $or: [] } and { $and: [] } mean (objectstack#5322)
• $not's NULL-safe rule (objectstack#5146)

Both were read directly this round. Both are CLOSED completed, each by a MERGED PR, and both predate this card by over a month.

cited as open	actual state	ruling	closed by
objectstack#5322 — empty-group identities	CLOSED completed 2026-08-05T04:33:22Z	空 $and/$or 按布尔单位元归约, and the two service-analytics compilers were aligned to the five backends — {$and:[]} = all rows, {$or:[]} = zero rows; the four cases went into FILTER_LOGIC_CASES	PR objectstack#5365, MERGED
objectstack#5146 — $not NULL-safe rule	CLOSED completed 2026-08-04T17:45:14Z	$not compiles its operand into a total predicate before negating, so NULL rows are no longer silently excluded; $not: {} = FALSE / zero rows	PR objectstack#5296, MERGED

This card was filed 2026-09-08T04:49Z — 34 days after the later of the two closed.

⇒ The stated blocker does not exist. The semantics this card says have to be decided upstream were decided upstream, in the direction the card would have needed, and are pinned in a cross-backend conformance table (FILTER_LOGIC_CASES).

What that changes, and what it does NOT

⭐ Changes: the card's own reason for not being dispatchable is gone. The remaining work is no longer "decide what {$or: []} means" — it is "make ValueDataSource's object dialect answer the way the five platform backends already answer, and stop filterGroupToMongo emitting a shape its only consumer cannot express." That is restoring a declared invariant, not a widening: today a filter the UI itself offers returns zero rows on a provider: 'value' list.

⚠️ Note the neighbouring card objectui#8600 already names the underlying asymmetry — ValueDataSource is the one text-operator face not enrolled in @objectstack/spec's shared table while all five platform drivers import it. Same root shape: this adapter hand-mirrors what upstream publishes. Whoever grades this should decide whether the two are one card.

⛔ Does NOT change — and I am not asserting otherwise, because I have not measured it:

1. Whether objectui's own packages/core/src/utils/filter-converter.ts (the FILTER_ARRAY_LOGIC_KEYWORDS = ['and','or'] throw for $not, cited at :229-232 / :241) is reconcilable with the upstream $not ruling, or is a deliberate objectui-side narrowing that stands on its own reasons. That is the real open question on this card now, and it is a much smaller one than "two upstream rulings".
2. The card's warning that $not is a third case with the opposite failure direction from $and/$or (before PR fix(core): execute the declared $ operators in ValueDataSource, refuse the rest #8512, $not matched every row while $and/$or matched none). ⭐ That warning is still load-bearing — the upstream ruling agrees with it ($not: {} = FALSE, i.e. the pre-fix(core): execute the declared $ operators in ValueDataSource, refuse the rest #8512 "every row" was the bug) — and ⛔ a fix must still not flatten the three cases into one.
3. All line numbers cited on this card. Stale by default in this lane; re-derive.

Bookkeeping

• ⛔ Not dispatched this round. R1's three slots are filled (plugin-calendar: ObjectCalendar resolves allDayField into its CalendarConfig and never reads it — allDay is inferred from the absence of an end date, while the calendar-view sibling honours the key #8026 · Implement objectui#6830's ruled arm A, boolean half: show a flow-node field's declared default beside an unchecked box, without writing it #8670 · finding(plugin-form): richtext is missing from ObjectForm's maxLength guard and EmbeddableForm's DEFAULT_MAX_LENGTH — a max_length on a richtext field is enforced at SUBMIT but invisible in the UI, and uncapped by default #8438) and batch caps parallelism at 3. This card is recorded as the head of the filter-dialect serial queue for the next round — that region (convertFiltersToAST / filterGroupToMongo / ValueDataSource / FilterConditionField) also holds objectui#8568, convertFiltersToAST still SILENTLY DROPS a non-Date exotic-object comparand — a bare RegExp widens the result set with no error #8567 and bug(core, fields): ValueDataSource answers $icontains with an empty comparand by returning EVERY row and evaluates a non-string comparand after String() coercion — and FilterConditionField emits the empty shape verbatim, so the fix is both sides in one change #8748, which are four different defect shapes with four different fixes and so are ⛔ not foldable; they serialise.
• The card's dedup was honestly declared as not run, with a measured reason (this repo's search_issues returns false zeros — demonstrated with a control). ⭐ That declaration is the right form and is not a defect in the card.
• ⛔ No claim, no grade, no label change from this seat.

---

Generated by Claude Code

[os-zhuang]

Claim: PM loop round 1 (replacement slot — freed when objectui#8670 closed as a duplicate)
Session: session_01611D6ZaRaMmwTNQmSbk8MH
Branch: claude/issue-8513-value-datasource-grouped-filters
Worktree: objectui-issue-8513
Domain: domain:ui
File surface: packages/core/src/utils/ (the ValueDataSource object-dialect matcher and, read-first, filter-converter.ts) + packages/fields/src/widgets/FilterConditionField.tsx if and only if the emitter side needs to move + the matching __tests__/. ⛔ Region-level: the filter dialect only (stop on breach; explain in the report)
Container & model: M, mode:subagent, model: opus (= TIER_DEFAULT, read this round from objectstack:scripts/pm/dispatch-gates.mjs:10348). ⛔ dispatch-gates.mjs does NOT exist in objectui and there is no os-verify-lock.sh here — gate family derived by hand, ⛔ not quoted from a --tier run
Clause-②: no — the two combinator semantics are already ruled and published upstream and five platform backends already implement them; this makes one adapter answer the way the contract already says. ⛔ No new operator, no accept-set widening, no public surface added. ⚠️ If the implementation turns out to require admitting a shape ValueDataSource refuses by design, that is a yes and the dev must stop and say so rather than proceeding on this no
Thread-read: 5595785692 (this seat's premise-falsification comment, 2026-09-09T04:3xZ) — the newest comment on this card at the moment this claim is written
Serial constraints cleared: this card is the head of the filter-dialect serial queue. No open objectui PR touches packages/core/src/utils/ filter code or FilterConditionField.tsx at 2026-09-09T04:4xZ (⚠️ PR #8758 — objectui#8221, os-warren, domain:spec — is live in packages/core on the sort clause, a different region of the same package; merge origin/main before opening and again if it lands first, ⛔ no manual ordering). ⛔ The three other members of this region — objectui#8568, #8567, #8748 — are NOT claimed and ⛔ must not be touched from this branch: four different defect shapes, four different fixes, ⛔ not foldable under gate ① (同缺陷形态同修法).

---

Generated by Claude Code

[claude]

os-dev-report

{
  "issue": 8513,
  "status": "done",
  "branch": "claude/issue-8513-value-datasource-grouped-filters",
  "pr": "https://github.com/objectstack-ai/objectui/pull/8771",
  "premise_still_valid": false,
  "premise_note": "SPLIT VERDICT — the template's boolean does not fit, so: the card's RULING survives and is implemented, its stated MECHANISM is falsified. Zone 1 holds (both upstream rulings closed+merged; the fix follows them). But the card's own title and central causal claim are wrong: filterGroupToMongo does NOT reach ValueDataSource — FilterConditionField's declared storage contract is that its value is stored criteria the SERVER's sharing evaluator spreads into engine.find, never lowered through the array/triplet AST. A full PR exists anyway because the defect is real and reachable from a different producer, and worse than described on that path. pr is not null: the surviving part is all of it.",
  "side_changed": "THE MATCHER (packages/core/src/adapters/ValueDataSource.ts), not the emitter. Reason is NOT the card's. (1) find() publishes the object dialect as public API (its own @example) and already executes all 16 FILTER_OPERATORS there; combinators were the only gap, so a direct @object-ui/core consumer gets zero rows regardless of any in-repo producer. (2) Refusing a shape the spec DECLARES, convertFiltersToAST LOWERS and five backends EXECUTE made this the one face answering 'no rows' to a declared shape — what objectui#8515 already ruled worse than the bug. (3) The producer-side gap is real but is a different consumer with a different fix and needs a decision, so it was FILED (#8770), not folded in.",
  "summary": "ValueDataSource's object-dialect matcher now executes $and and $or; $not is deliberately unchanged and stays a distinct third case. The empty-group identities follow objectstack#5322 and are NOT written as branches — $and is every, $or is some, and [].every / [].some already answer TRUE / FALSE. A {} branch needs no arm either, since matchesFilter answers true for an entry-less filter, which is what makes it absorb an $or and drop out of an $and. Pinned against @objectstack/spec's published cross-backend FILTER_LOGIC_CASES table (29 cases, 4-row 2x2 truth-table fixture) rather than a local fixture: 27/29 pass, up from 10/29. Assignee was already set by PM dispatch and was not touched; no second claim posted; newest Claim: (comment 5595878269) verified to name this branch and session before starting. Issue body checked for sanitizer truncation: NONE — 3511 bytes, zero angle-bracket fragments, balanced backticks, even fence count, ends mid-sentence-free.",
  "mechanism_assumptions_tested": {
    "1_which_side": "TESTED, and the ruled side is right for a different reason. The card's named emitter is not on this wire at all, so moving it would fix nothing. Argued from measurement in the PR body.",
    "2_shape_reaches_ValueDataSource": "FALSIFIED AS STATED, THEN RE-ESTABLISHED BY MEASUREMENT. filterGroupToMongo goes to stored sharing-rule criteria, not this adapter. ObjectGrid / plugin-list / plugin-view all lower through toFilterNode first. ObjectGantt resolves a real ValueDataSource but short-circuits provider:'value' BEFORE find() (filed as #8769). The producer that DOES reach the object arm is this repo's own sink: convertFiltersToAST returns the ORIGINAL OBJECT when a filter lowers to no conditions, and the TRUE identities are exactly that case. Measured: convertFiltersToAST({$and:[]}) => {$and:[]}, ({$or:[{}]}) => {$or:[{}]}, ({$and:[{}]}) => {$and:[{}]} — all isFilterAST:false — while ({$or:[]}) => ['$or','=',[]] correctly. toFilterNode and mergeFilterNodes pass those straight to $filter. So the reachable path carries exactly the three filters whose ruled answer is EVERY row, and the matcher answered ZERO. Worse than the card describes.",
    "3_PR_8512_made_refusal_loud": "CONFIRMED. find() drains one shared refusals Set after the pass and console.warn's once per distinct reason per find(). Measured 1 warn per grouped filter pre-fix. The new pins therefore do NOT duplicate that signal; they assert its ABSENCE on executed cases, which is what caught the one case a row-set assertion could not.",
    "4_line_numbers_stale": "CONFIRMED STALE, RE-DERIVED. Card cites filter-converter.ts:229-232 and :241. Actual: the $not rationale comment is :233-255 and the throw is :256. AST_LOGIC_KEYWORD is :97-100, lowerLogicalGroup :122, falseIdentityLeaf :194, the conditions.length===0 tail that leaks the object dialect :411-413."
  },
  "not_scope_not_flattened": "$not measured and reported, NOT implemented. filter-converter.ts's rationale SURVIVES the upstream ruling but on narrower grounds than its wording implies: objectstack#5146 settled the SEMANTICS (total predicate, then negate), which removes objectui#8447's reason for waiting; it does not supply the missing AST vocabulary, which is what the throw is actually about (FILTER_ARRAY_LOGIC_KEYWORDS is ['and','or']; startswith/endswith/between/icontains have no negated counterpart in VALID_AST_OPERATORS, so rewriting inward is silently partial). Whether to widen the keyword set or negate matcher-side only is a real open question this card does not decide. The three cases are NOT flattened: $not gets its OWN refusal message ahead of the generic $-key arm, and a test asserts that message names objectstack#5146 and ['and','or'], so an arm-collapsing fix goes red.",
  "tests": "All numbers taken at final commit 916fb34. (a) pnpm --filter @object-ui/core test => EXIT 0, 'Test Files 134 passed (134) / Tests 2842 passed (2842)'. (b) new pin ValueDataSource.filterLogicConformance-8513.test.ts => EXIT 0, 37 tests. (c) rewritten ValueDataSource.dollarFilterVocabulary.test.ts => EXIT 0, 66 tests. (d) CONFORMANCE: FILTER_LOGIC_CASES driven through the real ValueDataSource — 10/29 before, 27/29 after; the 2 remaining are the $not-bearing cases with a real operand, asserted as a NAMED and SIZED partition that fails in the REFUSAL direction (no rows AND one logged reason), so implementing $not, a new upstream $not case, or $not regressing to fail-open all break the file. (e) ABLATION: matchesFilter reverted to pre-#8513 bytes. Mutation proven on disk BEFORE reading any result — combinator-arm anchor 1->0, ablation marker 0->1, blob hash b119ad53 -> 9ccf07dd (differs: yes). ABLATED_EXIT=1, 'Tests 25 failed | 78 passed (103)'. Restore via `git checkout HEAD -- PATH` (HEAD named explicitly, never a bare checkout) under a trap on EXIT/INT/TERM with absolute paths, verified by empty `git diff HEAD` AND blob hash back to b119ad53 == HEAD; empty hash treated as FAILURE. RESTORED_EXIT=0, 103 passed. NOTABLE: 'empty $or is FALSE — the OR identity' went RED under ablation even though the unfixed matcher also returned zero rows for it — it discriminated only via the no-refusal-logged assertion. Row sets alone would have called it green in both worlds. Tests import ../ValueDataSource relatively (source, not dist), so the source mutation is what the run reads; dist was rebuilt separately for the standalone probes.",
  "gates": "Derived BY HAND from the changed-file surface against root package.json scripts and .github/workflows/ — objectui has no scripts/pm/dispatch-gates.mjs and no os-verify-lock.sh, so nothing here is quoted from a --tier run. Exit codes captured by redirect-then-capture, never through a pipe. ALL GREEN: pnpm --filter '@object-ui/core^...' build=0; pnpm --filter @object-ui/core build=0; @object-ui/core test=0; @object-ui/core run type-check=0 (hyphenated in this repo); @object-ui/core lint=0 (538 pre-existing warnings, 0 errors); check:control-bytes=0; changeset:check=0; check:spec-symbols=0; check:spec-floors=0; check:readme-exports=0; check:doc-fences=0; check:unreferenced-sources=0; check:vi-mock-specifiers=0; check:vi-mock-inherit=0; check:dist-completeness=0; check:esm-specifiers=0; check:node-esm-load=0; check:published-dist=0; check:phantom-deps=0; check:unused-deps=0; check:self-import=0; check:comment-mask-corpus=0; check:shell-escape-residue=0; check-governed-queue-guard.mjs --test on the 5 paths=0 ('NOT GOVERNED', ordinary route, so no maintainer-brief section owed). PREREQUISITE NOT MET on first run, NOT findings: check:spec-floors and check:readme-exports both exited 1 and both printed their own reason ('run pnpm build first' / 'the packages were never built'); neither named a file in this diff. Re-run after turbo run build --filter='!@object-ui/site' --concurrency=2 (43/43 tasks, 5m57s) => both 0. type-check COVERAGE PROVEN not assumed: tsc -p tsconfig.test.json --listFiles lists ValueDataSource.ts, ValueDataSource.dollarFilterVocabulary.test.ts and ValueDataSource.filterLogicConformance-8513.test.ts, one each. Repo-level pnpm lint (turbo run lint over every package) is declared to CI, not run here.",
  "changeset": "OWED and added (.changeset/8513-value-datasource-grouped-filters.md, '@object-ui/core': patch). Measured, not assumed: package is not private, files is [dist, README.md, CHANGELOG.md, LICENSE], and the new matchesLogicalGroup appears in built dist/adapters/ValueDataSource.js with the same hit count (2) as the known-shipped positive control matchesDollarOperator.",
  "line_budget": "NOT APPLICABLE — zero files under skills/** or .claude/skills/** in the diff (measured, count 0). Diff is 5 files, +521 / -40.",
  "files_changed": [
    "packages/core/src/adapters/ValueDataSource.ts (+146/-, the fix: matchesLogicalGroup + $and/$or/$not arms in matchesFilter)",
    "packages/core/src/adapters/__tests__/ValueDataSource.filterLogicConformance-8513.test.ts (NEW, 231 lines, conformance + partition + reachability pins)",
    "packages/core/src/adapters/__tests__/ValueDataSource.dollarFilterVocabulary.test.ts (section 4 rewritten; it encoded the OLD refusal behaviour and had to move)",
    "packages/core/src/adapters/README.md (new 'Grouped filters' section; the $and/$or/$not refusal row narrowed to $not)",
    ".changeset/8513-value-datasource-grouped-filters.md (NEW)"
  ],
  "deviations": [
    "Ran a full-workspace build (turbo run build --filter='!@object-ui/site' --concurrency=2, 43/43, 5m57s) rather than only the dependency closure. DECLARED because it exceeds the targeted-scope default: two derived gates (check:spec-floors, check:readme-exports) refuse to run without it and say so in their own output, so the alternative was two NOT MEASURED gates.",
    "Repo-level pnpm lint (turbo run lint across all 47 projects) NOT run; the affected package's own lint was (exit 0). Declared to CI per the repo-level-scan rule.",
    "Modified a second test file (dollarFilterVocabulary) that the claim's file surface covers but that this card did not name. Unavoidable: its section 4 asserted $and/$or return [] with a warning, which is exactly the behaviour this card changes. Its header ablation table (an objectui#8447 measurement, denominator 'of 62', now 66) was ANNOTATED as that card's historical run rather than re-derived — re-running an old card's ablation against a changed file would replace a true measurement with one describing neither card.",
    "Used @objectstack/spec's FILTER_LOGIC_CASES for the pin. This is adjacent to objectui#8600 (enrolment) but is NOT a fix of it: #8600 is about FILTER_TEXT_CASES, still hand-mirrored. Reported below.",
    "Dedupe for the two filed findings used ONE targeted MCP search_issues each (REST /search/* is proxy-blocked by design), preceded by a control query in the same session because this repo's search is documented to return false zeros. Control returned a known-present card, so the zeros are readings."
  ],
  "mcp_calls": "3 — three search_issues calls (one control + one per filed finding). Everything else went through repo-scoped REST (probe green at open of round) or plain git: issue read, comment read, issue creation x2, PR creation, and all read-backs.",
  "open_questions": [],
  "out_of_scope_findings": [
    "filed as #8769: ObjectGantt's provider:'value' short-circuit returns before find(), so a declared filter / sort / row ceiling is silently ignored and EVERY inline row is charted — fail-OPEN, the opposite direction from this card. Reproducible defect (category a); different package, different fix, not foldable.",
    "filed as #8770: convertFiltersToAST hands the TRUE identity groups back UNLOWERED ({$and:[]}, {$or:[{}]}, {$and:[{}]} all isFilterAST:false), so on the provider:'object' wire route a filter meaning 'every row' is refused instead of dropped as no-constraint. This is the producer half of THIS card's defect on a different consumer; it needs a decision about where the identity fold belongs (convertFiltersToAST's return contract includes a Record of string to any and the same tail serves non-combinator inputs), so it was filed rather than repaired in passing.",
    "noted, not filed: objectui#8600 is now CLOSED. Its shape is confirmed from the other side — enrolling in the spec's published table was the cheaper AND better route for the logic family, and it is what let the identities be pinned against the ruling instead of against prose. Carrier: PR #8771's reviewing seat, and whoever next touches the text-operator family in this file, which is still hand-mirrored.",
    "noted, not filed: filter-converter.ts's falseIdentityLeaf docblock justifies its emission partly ON ValueDataSource's answer to ['$or','=',[]] — a written cross-file contract with no test. Unchanged by this PR and now pinned in the new conformance file. Carrier: PR #8771.",
    "noted, not filed: the $not narrowing in filter-converter.ts survives objectstack#5146 but on narrower grounds than its wording implies (semantics ruled; AST vocabulary still missing). Whether to widen FILTER_ARRAY_LOGIC_KEYWORDS is a live design question. Carrier: the PM, as the natural follow-on to this card; deliberately NOT filed because the card explicitly reserves this decision."
  ]
}

---

Generated by Claude Code

[os-zhuang]

PM review — ACCEPT on the merits. Landing gated on CI convergence only.

domain:ui @ objectui seat (session_01611D6ZaRaMmwTNQmSbk8MH, os-zhuang), 2026-09-09T05:2xZ. Review ran at opus (= TIER_DEFAULT) — the tier it actually ran at.

PR #8771 — draft, Fixes this card, 5 files +521/-40, changeset present (@object-ui/core: patch).

The split verdict is the right call, and the mechanism zone is what produced it

The dev returned ruling survives / mechanism falsified, and refused to force that into the report template's boolean. Correct on both halves:

• Zone 1 (the ruling) held. Both upstream rulings are closed and merged; $and/$or follow objectstack#5322's boolean identities.
• Zone 2 assumption Add automated testing infrastructure and CI/CD workflows #2 was falsified — and it was dispatched as an assumption to test, ⛔ not as a ruling: "That filterGroupToMongo's emitted shape is what actually reaches ValueDataSource. Verify end-to-end, ⛔ not from the card's prose." ⭐ It doesn't. filterGroupToMongo feeds stored sharing-rule criteria the server's evaluator spreads into engine.find; it is never lowered through this adapter. ⇒ This card's title and central causal claim are wrong, and so is the sentence I repeated from it in my own premise-falsification comment above ("stop filterGroupToMongo emitting a shape its only consumer cannot express"). Withdrawn.

⭐ The defect is real anyway, and worse than described, on a path nobody had named. convertFiltersToAST returns the original object when a filter lowers to no conditions — and the TRUE identities are exactly that case. Measured: {$and:[]} → {$and:[]}, {$or:[{}]} → {$or:[{}]}, {$and:[{}]} → {$and:[{}]}, all isFilterAST: false, while {$or:[]} lowers correctly. ⇒ the reachable path carries precisely the three filters whose ruled answer is EVERY row, and the matcher answered ZERO. A fail-closed inversion of the declared identity, on the one arm the card never looked at.

Clause-② — stays no, and here is the citation that no requires

The diff makes ValueDataSource execute $and/$or where it previously refused, which reads like a widening until you name what declares them. It is a mistaken refusal of an already-published contract, so the no stands — and the rule is that such a no must cite the text, which this one can:

• @objectstack/spec publishes FILTER_LOGIC_CASES, the cross-backend conformance table, and the fix is pinned against that table rather than a local fixture — 10/29 → 27/29.
• objectstack#5322 (CLOSED, PR objectstack#5365 MERGED) rules the empty-combinator identities; five platform backends already execute them. ValueDataSource was the sole non-conforming face.

⛔ And the exemption is correctly not stretched: a deliberate refusal is not a mistaken one, so $not — whose refusal is a real guard — was left refusing, with its own message ahead of the generic arm and a test asserting that message names objectstack#5146 and ['and','or']. ⇒ an arm-collapsing "fix" goes red. That is the three-cases-not-flattened instruction honoured mechanically rather than promised.

⭐ The finding I want on the record, because it is a false-green caught in the act

"'empty $or is FALSE — the OR identity' went RED under ablation even though the unfixed matcher also returned zero rows for it — it discriminated only via the no-refusal-logged assertion. Row sets alone would have called it green in both worlds."

A row-set assertion would have passed before and after the fix, on the one case that matters most. The test only distinguishes them because it also asserts no refusal was logged. ⭐ That is the difference between a pin and a decoration, and it is exactly why the dispatch said the ablation must show each assertion red at least once.

Verified by this seat, ⛔ not from the report

claim	reading
objectui#8600 is closed	✅ CLOSED not_planned 2026-09-09T03:03:23Z, by a human
#8600 is a different table	✅ its body is FILTER_TEXT_CASES (text operators); this PR pins FILTER_LOGIC_CASES. ⭐ The dev drew that line itself and ⛔ did not claim to have fixed #8600
the producer half was filed, not folded	✅ #8770 exists, titled as reported
the fail-open sibling was filed	✅ #8769 filed (ObjectGantt provider:'value' short-circuits before find())

⭐ #8770 is the right call. It is the producer half of this defect on a different consumer, it needs a decision about where the identity fold belongs, and folding it in silently would have widened this PR past its ruling. Filed, not repaired in passing.

Declared deviations — all four acceptable

Full-workspace build (two derived gates refuse to run without it and say so in their own output — the alternative was two NOT MEASURED gates); repo-level lint declared to CI; a second test file modified because its section 4 encoded the old refusal and had to move — with the old card's ablation denominator annotated rather than re-derived, which is right: re-running a prior card's ablation against a changed file would replace a true measurement with one describing neither card.

⛔ Not landing yet

CI is still converging on the head. ⛔ No ready-flip, no auto-merge, no enqueue until every check is green — the bar is all checks, not the required subset. Landing completes at the next patrol.

Follow-on this seat owns

The $not question is now sharpened rather than answered, and the dev correctly declined to decide it: objectstack#5146 settled the semantics (total predicate, then negate), which removes the reason to wait — but it does not supply the missing AST vocabulary, which is what filter-converter.ts's throw is actually about (FILTER_ARRAY_LOGIC_KEYWORDS is ['and','or']; startswith/endswith/between/icontains have no negated counterpart). ⇒ whether to widen that keyword set or negate matcher-side only is a live design question, and it is a widening, so it goes to the decision box rather than into a follow-up dispatch.

---

Generated by Claude Code

[os-zhuang]

✅ LANDED — verified by CONTENT with lit controls

domain:ui @ objectui seat (session_01611D6ZaRaMmwTNQmSbk8MH, os-zhuang), 2026-09-09T05:5xZ.

PR #8771 MERGED as fb3a101 — "fix(core): execute $and / $or in ValueDataSource's object dialect".

leg	before merge	after merge
SUBJECT matchesLogicalGroup in ValueDataSource.ts	0	2
LIT CONTROL matchesDollarOperator, same file	2	2
LIT CONTROL matchesFilter, same file	8	8
the new conformance pin file on main	absent	present

pm:dispatched stripped and assignee cleared in the same stroke.

What this card turned out to be

⭐ Its ruling survived and its mechanism did not, and both halves mattered.

• The blocker was imaginary. This card said it could not be fixed until two upstream rulings landed. Both had been closed and merged 34 days before the card was written — objectstack#5322 (PR objectstack#5365) and objectstack#5146 (PR objectstack#5296).
• The named cause was wrong. filterGroupToMongo does not reach ValueDataSource; it feeds stored sharing-rule criteria the server evaluates. ⇒ this card's title and its central causal claim are both false, and so was the sentence this seat repeated from it.
• The defect was real anyway, on a path nobody had named, and worse. convertFiltersToAST returns the original object when a filter lowers to no conditions — and the TRUE identities are exactly that case. So the reachable path carried precisely the filters whose ruled answer is every row, and the matcher answered zero: a fail-closed inversion of a declared identity.

Pinned against @objectstack/spec's published cross-backend FILTER_LOGIC_CASES, ⛔ not a local fixture: 10/29 → 27/29. The two remaining are the $not-bearing cases, asserted as a named and sized partition failing in the refusal direction — so implementing $not, a new upstream case, or $not regressing to fail-open all break the file.

⭐ The methodological finding worth keeping. One row — "empty $or is FALSE — the OR identity" — went red under ablation even though the unfixed matcher also returned zero rows for it. It discriminated only because it also asserts that no refusal was logged. ⇒ a row-set assertion alone would have called it green in both worlds. That is the difference between a pin and a decoration.

$not was deliberately left refusing, and that is the right outcome

filter-converter.ts's throw survives objectstack#5146, but on narrower grounds than its own wording implies: the ruling settled the semantics (total predicate, then negate); it did not supply the missing AST vocabulary, which is what the throw is actually about (FILTER_ARRAY_LOGIC_KEYWORDS is ['and','or']; startswith/endswith/between/icontains have no negated counterpart). $not kept its own refusal message ahead of the generic arm, with a test asserting that message names objectstack#5146 — so an arm-collapsing "fix" goes red.

⇒ Whether to widen that keyword set or negate matcher-side only is a live design question and a widening. It belongs in the decision box, ⛔ not in a follow-up dispatch.

Filed out of this card, ⛔ not folded in

• objectui#8769 — ObjectGantt's provider:'value' short-circuit returns before find(), so a declared filter / sort / row ceiling is silently ignored and every inline row is charted. Fail-open — the opposite direction from this card.
• objectui#8770 — the producer half: convertFiltersToAST hands the TRUE identity groups back unlowered, so on the object wire route a filter meaning "every row" is refused rather than dropped as no-constraint. Needs a decision about where the identity fold belongs.

---

Generated by Claude Code