@@ -0,0 +1,18 @@
+---
+'@object-ui/core': minor
+---
+
+fix(core): `evaluatePlainCondition` reads a bare-string predicate as CEL, the way the spec defines it and `evaluateCondition` reads it
+
+Clause-②: no (narrowing)
+Metadata-protocol: narrowed
+
+`@objectstack/spec` defines a bare string in a predicate slot as shorthand for `{ dialect: 'cel', source }`, the server evaluates it on CEL, and `ExpressionEvaluator.evaluateCondition` reads it on CEL. The published `evaluatePlainCondition(condition, record)` export still read a bare string on the legacy JavaScript expression grammar, so a host calling it got the opposite dialect from every other predicate path: a CEL-only predicate such as `status in ['overdue', 'urgent']` or `size(tags) > 0` faulted and answered `false`.
+
+- A bare string handed to `evaluatePlainCondition` is evaluated on the canonical `@objectstack/formula` CEL engine, the route `evaluateCondition` gives it, so a predicate that evaluates gets the same verdict from both. Record fields stay readable both bare (`status`) and under `data.` (`data.status`).
+- The function's answer is unchanged in shape: `true` only when the predicate evaluates to `true`; a fault, a non-boolean result and a blank condition answer `false`, with no console line.
+- Unchanged: a `${…}` template is still evaluated on the legacy engine.
+
+**BREAKING**: a bare string passed to `evaluatePlainCondition` is read on CEL only, as the spec defines it. A predicate that relied on syntax only the legacy JavaScript grammar reads (for example `===`, `!==`, `?.`, `??`, `.includes(…)` or `.length`) now faults and the function answers `false` where it used to evaluate. Write the predicate in CEL, the one predicate language the spec and the server define (ADR-0032): equality is `==`, membership is `in`, a substring test is `.contains(…)`, a length is `size(…)`, a presence test is `has(…)`. Measured in this repository, nothing outside its own tests calls the export.
+
+<!-- adr-0087: not-required (no-migration-prescription) the narrowed operand is the condition argument a host passes to the evaluatePlainCondition function at runtime, not metadata: no packages/spec schema declares it, no stored row or package source carries it, and its only reader is this function, so there is nothing for objectstack migrate meta to rewrite -->
@@ -710,20 +710,31 @@ export function evaluateCondition(
 /**
  * Convenience function to evaluate a plain condition string against a data record.
  * Supports both template expressions (e.g., '${data.amount > 1000}') and
- * plain expressions (e.g., "status == 'overdue'").
+ * bare CEL predicates (e.g., "status == 'overdue'").
  * Record fields are available both directly (status) and namespaced (data.status).
+ *
+ * A bare string is CEL (objectstack#27605): the spec defines it as shorthand for
+ * `{ dialect: 'cel', source }`, so it takes the CEL route
+ * {@link ExpressionEvaluator.evaluateCondition} gives it and a predicate that
+ * evaluates reaches the same verdict on both. Only a `${…}` template stays on
+ * the legacy engine. The answer is
+ * `true` only when the predicate evaluates to `true`: a fault (a JS-only
+ * spelling such as `===` included), a non-boolean result and a blank condition
+ * all answer `false`.
  */
 export function evaluatePlainCondition(
   condition: string,
   record: Record<string, any>
 ): boolean {
+  if (typeof condition !== 'string' || isBlankPredicateText(condition)) {
+    return false;
+  }
   const evaluator = new ExpressionEvaluator({ ...record, data: record }, globalCache, globalFormulas);
   try {
-    const isTemplate = /\$\{/.test(condition);
-    const result = isTemplate
-      ? evaluator.evaluate(condition, { throwOnError: true })
-      : evaluator.evaluateExpression(condition);
-    return result === true;
+    if (/\$\{/.test(condition)) {
+      return evaluator.evaluate(condition, { throwOnError: true }) === true;
+    }
+    return evaluator.evaluateCondition(condition, { throwOnError: true });
   } catch {
     return false;
   }
 
@@ -175,22 +175,77 @@ describe('evaluatePlainCondition', () => {
   });
 
   it('should evaluate compound conditions', () => {
-    expect(evaluatePlainCondition("amount > 1000 && status === 'urgent'", { amount: 2000, status: 'urgent' })).toBe(true);
-    expect(evaluatePlainCondition("amount > 1000 && status === 'urgent'", { amount: 2000, status: 'normal' })).toBe(false);
+    expect(evaluatePlainCondition("amount > 1000 && status == 'urgent'", { amount: 2000, status: 'urgent' })).toBe(true);
+    expect(evaluatePlainCondition("amount > 1000 && status == 'urgent'", { amount: 2000, status: 'normal' })).toBe(false);
+  });
+
+  // objectstack#27605 — a bare string is CEL, as the spec defines it and
+  // `evaluateCondition` reads it.
+  it('reads a bare string as CEL: CEL-only constructs evaluate', () => {
+    expect(evaluatePlainCondition("status in ['overdue', 'urgent']", { status: 'urgent' })).toBe(true);
+    expect(evaluatePlainCondition("status in ['overdue', 'urgent']", { status: 'active' })).toBe(false);
+    expect(evaluatePlainCondition('size(tags) > 0', { tags: ['vip'] })).toBe(true);
+    expect(evaluatePlainCondition('size(tags) > 0', { tags: [] })).toBe(false);
+  });
+
+  it('refuses a JS-only spelling with false, even where it would hold on the JS grammar', () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    try {
+      expect(evaluatePlainCondition("amount > 1000 && status === 'urgent'", { amount: 2000, status: 'urgent' })).toBe(false);
+      expect(evaluatePlainCondition("name.includes('Acme')", { name: 'Acme Corp' })).toBe(false);
+      // Control: the CEL spelling of the same two predicates holds.
+      expect(evaluatePlainCondition("amount > 1000 && status == 'urgent'", { amount: 2000, status: 'urgent' })).toBe(true);
+      expect(evaluatePlainCondition("name.contains('Acme')", { name: 'Acme Corp' })).toBe(true);
+      // The fault is answered by the return value, as before: no console line.
+      expect(warn).not.toHaveBeenCalled();
+    } finally {
+      warn.mockRestore();
+    }
+  });
+
+  it('reads data.field in a bare CEL predicate as well as the bare field', () => {
+    expect(evaluatePlainCondition('data.amount > 1000', { amount: 2000 })).toBe(true);
+    expect(evaluatePlainCondition('data.amount > 1000', { amount: 500 })).toBe(false);
+  });
+
+  it('gives the verdict evaluateCondition gives for the same string and record', () => {
+    const cases: Array<[string, Record<string, unknown>]> = [
+      ["status == 'overdue'", { status: 'overdue' }],
+      ["status == 'overdue'", { status: 'active' }],
+      ['amount > 1000 && data.amount < 5000', { amount: 2000 }],
+      ['amount > 1000 && data.amount < 5000', { amount: 9000 }],
+      ["status in ['a', 'b']", { status: 'b' }],
+      ['size(tags) > 1', { tags: ['x'] }],
+    ];
+    for (const [source, record] of cases) {
+      const viaCondition = new ExpressionEvaluator({ ...record, data: record }).evaluateCondition(source);
+      expect(evaluatePlainCondition(source, record)).toBe(viaCondition);
+    }
   });
 
   it('should support data.field references in template expressions', () => {
     expect(evaluatePlainCondition('${data.amount > 1000}', { amount: 2000 })).toBe(true);
     expect(evaluatePlainCondition('${data.amount > 1000}', { amount: 500 })).toBe(false);
   });
 
+  it('keeps a template on the legacy engine', () => {
+    // `===` is a JS-only spelling: still read inside a `${…}` template.
+    expect(evaluatePlainCondition("${data.status === 'urgent'}", { status: 'urgent' })).toBe(true);
+    expect(evaluatePlainCondition("${data.status === 'urgent'}", { status: 'normal' })).toBe(false);
+  });
+
   it('should return false for invalid expressions', () => {
     expect(evaluatePlainCondition('!!!invalidSyntax', { status: 'ok' })).toBe(false);
   });
 
   it('should return false for non-boolean results', () => {
     expect(evaluatePlainCondition('status', { status: 'active' })).toBe(false);
   });
+
+  it('should return false for a blank condition', () => {
+    expect(evaluatePlainCondition('', { status: 'active' })).toBe(false);
+    expect(evaluatePlainCondition('   ', { status: 'active' })).toBe(false);
+  });
 });
 
 // ─── CSP Safety Tests ──────────────────────────────────────────────────────