test(integration): expand corpus — like, ne, isNull filter operators

Adds two new query scenarios so the corpus exercises more of the filter-op
vocabulary both runners advertise. Plus one real bug surfaced by the new
isNull scenario.

- queries/filter-like-and-ne.yaml: Program titles via `like "Found%"` +
  status via `ne "PUBLISHED"`. Like pattern is case-aligned so the test
  doesn't depend on LIKE-vs-ILIKE wiring.
- queries/filter-is-null.yaml: Week label `isNull: true` + `isNull: false`,
  verifying `IS NULL` translation (not `= NULL`, which is always false).

Bug fix surfaced by the new scenario:
- C# DbContextAdapter.BuildOp: `isNull` was checking `rawValue is true`,
  but YamlDotNet deserializes a YAML boolean into a `string` ("true" /
  "false") when the target is `object?`. The dispatch silently took the
  `Expression.Not(...)` branch — `isNull: true` returned the rows where
  label was NOT NULL. Fix: accept both `bool` and `string` shapes; throw
  on anything else so a future malformed scenario fails loud.

Gates: TS integration 11/11, C# integration 11/11.

Author: dmealing

fixtures/persistence-conformance/queries/filter-is-null.yaml

@@ -0,0 +1,32 @@
+name: filter-is-null
+description: |
+  Filter Weeks with `isNull` on a nullable field. Verifies the runner
+  translates `{ field: { isNull: true } }` to SQL `IS NULL` (not `= NULL`,
+  which is always false in three-valued logic) and that `{ isNull: false }`
+  surfaces the complementary row set.
+seed-data: |
+  INSERT INTO "programs" ("id", "title", "priceCents", "status", "createdAt") VALUES
+    (1, 'Foundations', 4999, 'PUBLISHED', '2026-05-01T10:00:00');
+  INSERT INTO "weeks" ("id", "programId", "label") VALUES
+    (1, 1, 'Week 1'),
+    (2, 1, NULL),
+    (3, 1, 'Week 3'),
+    (4, 1, NULL);
+queries:
+  - name: weeks-with-null-label
+    op: list
+    entity: Week
+    filter: { label: { isNull: true } }
+    sort: [{ field: id, dir: asc }]
+    expect:
+      - { id: "2", programId: "1", label: null }
+      - { id: "4", programId: "1", label: null }
+
+  - name: weeks-with-non-null-label
+    op: list
+    entity: Week
+    filter: { label: { isNull: false } }
+    sort: [{ field: id, dir: asc }]
+    expect:
+      - { id: "1", programId: "1", label: "Week 1" }
+      - { id: "3", programId: "1", label: "Week 3" }

fixtures/persistence-conformance/queries/filter-like-and-ne.yaml

@@ -0,0 +1,29 @@
+name: filter-like-and-ne
+description: |
+  Filter Programs with `like` (SQL pattern match) and `ne` (not-equal). Both
+  ports must surface the same rows, in the same order. The `like` pattern is
+  case-aligned to the seed data (no case-fold dependency) so the test passes
+  whether a port wires LIKE or ILIKE under the hood.
+seed-data: |
+  INSERT INTO "programs" ("id", "title", "priceCents", "status", "createdAt") VALUES
+    (1, 'Foundations', 4999, 'PUBLISHED', '2026-05-01T10:00:00'),
+    (2, 'Strength',    7999, 'PUBLISHED', '2026-05-02T10:00:00'),
+    (3, 'Mobility',    2999, 'DRAFT',     '2026-05-03T10:00:00'),
+    (4, 'Archived',    1999, 'ARCHIVED',  '2026-05-04T10:00:00');
+queries:
+  - name: title-like-prefix
+    op: list
+    entity: Program
+    filter: { title: { like: "Found%" } }
+    sort: [{ field: id, dir: asc }]
+    expect:
+      - { id: "1", title: "Foundations", priceCents: "4999", status: "PUBLISHED", createdAt: "2026-05-01T10:00:00" }
+
+  - name: status-not-published
+    op: list
+    entity: Program
+    filter: { status: { ne: "PUBLISHED" } }
+    sort: [{ field: id, dir: asc }]
+    expect:
+      - { id: "3", title: "Mobility", priceCents: "2999", status: "DRAFT",    createdAt: "2026-05-03T10:00:00" }
+      - { id: "4", title: "Archived", priceCents: "1999", status: "ARCHIVED", createdAt: "2026-05-04T10:00:00" }

server/csharp/MetaObjects.IntegrationTests/Runner/DbContextAdapter.cs

@@ -125,11 +125,20 @@ private static IQueryable<T> ApplyFilter<T>(IQueryable<T> queryable, IReadOnlyDi
 
     private static Expression BuildOp(Expression propExpr, string op, object? rawValue)
     {
-        // null/IsNull operators don't need value coercion.
+        // null/IsNull operators don't need value coercion (other than the bool flag).
+        // YamlDotNet deserializes a YAML bool into a `string` when the target is
+        // `object?`, so accept both shapes here.
         if (op == "isNull")
         {
             var isNullExpr = Expression.Equal(propExpr, Expression.Constant(null, propExpr.Type));
-            return rawValue is true ? isNullExpr : Expression.Not(isNullExpr);
+            var wantNull = rawValue switch
+            {
+                bool b => b,
+                string s when bool.TryParse(s, out var parsed) => parsed,
+                _ => throw new InvalidOperationException(
+                    $"filter op `isNull` requires a boolean value (got: {rawValue?.GetType().Name ?? "null"})"),
+            };
+            return wantNull ? isNullExpr : Expression.Not(isNullExpr);
         }
 
         // `in` takes a list of values.