@@ -404,9 +404,13 @@ let recordScopeEnv: Environment | undefined;
  *    faults `has() invalid argument`. `@objectstack/lint`'s
  *    `validate-visibility-predicates` masks `has(…)` spans at its own call site
  *    (#16118) and that mask stays load-bearing; no other consumer has one.
- *    A select whose receiver is an index or a call (`has(a[0].b)`) is NOT in
- *    this class: the spec admits it, and {@link rewriteIndexedHas} lowers it
- *    before this check runs (#25267).
+ *    The page/view door now REPORTS the argument itself, under
+ *    `visibility-predicate-has-argument` (#25281); on every other surface
+ *    `validateExpression`'s compile pass refuses it. Neither changes what this
+ *    helper answers: a `has()` first error still masks the references behind
+ *    it here. A select whose receiver is an index or a call (`has(a[0].b)`) is
+ *    NOT in this class: the spec admits it, and {@link rewriteIndexedHas}
+ *    lowers it before this check runs (#25267).
  *
  * ⇒ A `null` from this helper is still "nothing was reported", never "the
  * source is clean". ⛔ Do not close the remaining classes by widening the regex
 
@@ -267,6 +267,7 @@ export {
   VISIBILITY_PREDICATE_SYNTAX,
   VISIBILITY_PREDICATE_OVER_BUDGET,
   VISIBILITY_PREDICATE_UNKNOWN_FUNCTION,
+  VISIBILITY_PREDICATE_HAS_ARGUMENT,
 } from './validate-visibility-predicates.js';
 export type {
   VisibilityFinding,
 
@@ -853,6 +853,23 @@ const VISIBILITY_PREDICATE_UNKNOWN_FUNCTION_EXPLANATION: RuleExplanation = {
   ],
 };
 
+const VISIBILITY_PREDICATE_HAS_ARGUMENT_EXPLANATION: RuleExplanation = {
+  rule: 'visibility-predicate-has-argument',
+  covers: 'what `has()` accepts as its argument',
+  paragraphs: [
+    'CEL defines the macro in one form, `has(e.f)`: a presence test on field `f` of whatever `e` ' +
+      'evaluates to, where `f` is a plain field name written after a dot. Any other argument — a name ' +
+      'alone (`has(status)`), an index as the last step (`has(record.items[0])`), a call, a literal or ' +
+      'an operator — is refused by the engine as `has() invalid argument` on every evaluation, whatever ' +
+      'the record holds. On a view or page surface the console then falls OPEN and the element renders ' +
+      'unconditionally, exactly like one carrying no predicate at all.',
+    'Write the test the definition admits: `has(record.status)` or `\'status\' in record` for a field ' +
+      '(`data` instead of `record` on a metadata-editing form), and `size(record.items) > 0` to ask whether ' +
+      'a list has a first element. `has()` over a selection whose receiver is indexed or called, such as ' +
+      '`has(record.items[0].name)`, is accepted.',
+  ],
+};
+
 const VISIBILITY_BARE_IDENTIFIER_EXPLANATION: RuleExplanation = {
   rule: 'visibility-bare-identifier',
   covers: 'why every value is read through a namespace',
@@ -4772,6 +4789,7 @@ export const RULE_EXPLANATIONS: Readonly<Record<string, RuleExplanation>> = Obje
   [VISIBILITY_PREDICATE_OVER_BUDGET_EXPLANATION.rule]: VISIBILITY_PREDICATE_OVER_BUDGET_EXPLANATION,
   [VISIBILITY_PREDICATE_SYNTAX_EXPLANATION.rule]: VISIBILITY_PREDICATE_SYNTAX_EXPLANATION,
   [VISIBILITY_PREDICATE_UNKNOWN_FUNCTION_EXPLANATION.rule]: VISIBILITY_PREDICATE_UNKNOWN_FUNCTION_EXPLANATION,
+  [VISIBILITY_PREDICATE_HAS_ARGUMENT_EXPLANATION.rule]: VISIBILITY_PREDICATE_HAS_ARGUMENT_EXPLANATION,
   [VISIBILITY_BARE_IDENTIFIER_EXPLANATION.rule]: VISIBILITY_BARE_IDENTIFIER_EXPLANATION,
   [HOOK_BODY_WRITE_UNKNOWN_FIELD_EXPLANATION.rule]: HOOK_BODY_WRITE_UNKNOWN_FIELD_EXPLANATION,
   [HOOK_BODY_WRITE_UNPROVISIONED_ANCHOR_EXPLANATION.rule]: HOOK_BODY_WRITE_UNPROVISIONED_ANCHOR_EXPLANATION,
 
@@ -43,6 +43,7 @@ import {
   VISIBILITY_BARE_IDENTIFIER,
   VISIBILITY_PREDICATE_OVER_BUDGET,
   VISIBILITY_PREDICATE_SYNTAX,
+  VISIBILITY_PREDICATE_HAS_ARGUMENT,
   VISIBILITY_PREDICATE_UNKNOWN_FUNCTION,
   VISIBILITY_ROOT_MISLAYERED,
 } from './validate-visibility-predicates.js';
@@ -59,6 +60,7 @@ const FAMILY_IDS = new Set<string>([
   VISIBILITY_BARE_IDENTIFIER,
   VISIBILITY_PREDICATE_OVER_BUDGET,
   VISIBILITY_PREDICATE_SYNTAX,
+  VISIBILITY_PREDICATE_HAS_ARGUMENT,
   VISIBILITY_PREDICATE_UNKNOWN_FUNCTION,
   VISIBILITY_ROOT_MISLAYERED,
   PREDICATE_PATH_UNRESOLVED,
@@ -90,6 +92,9 @@ const REFUSED = [
   // A wrong reference: no binding root resolves `status`.
   { body: "status == 'open'", rule: VISIBILITY_BARE_IDENTIFIER, subject: '`status`' },
   { body: 'record.status ==', rule: VISIBILITY_PREDICATE_SYNTAX, subject: 'not valid CEL' },
+  // [#25281] A `has()` argument the engine refuses: a bare name, an index as the last step.
+  { body: 'has(status)', rule: VISIBILITY_PREDICATE_HAS_ARGUMENT, subject: '`status`' },
+  { body: 'has(record.items[0])', rule: VISIBILITY_PREDICATE_HAS_ARGUMENT, subject: '`record.items[0]`' },
 ] as const;
 
 /**
@@ -198,6 +203,10 @@ describe('#24491 — the page door gives the build\'s visibility-predicate verdi
     expect(fn.map((f) => [f.rule, f.path])).toEqual([
       [VISIBILITY_PREDICATE_UNKNOWN_FUNCTION, 'views[0].form.sections[0].fields[0]'],
     ]);
+    // [#25281] The `has()` argument arm reaches the view door the same way.
+    expect(family(gateView(view('has(status)')).errors).map((f) => [f.rule, f.path])).toEqual([
+      [VISIBILITY_PREDICATE_HAS_ARGUMENT, 'views[0].form.sections[0].fields[0]'],
+    ]);
     // The path half is live on the view surface it was built for.
     const path = family(gateView(view("data.tpye == 'text'", { provider: 'schema', schemaId: 'field' })).errors);
     expect(path.map((f) => f.rule)).toContain(PREDICATE_PATH_UNRESOLVED);