@@ -11,7 +11,7 @@ import type { KeySetGuidance } from '../shared/suggestions.zod';
 import { SELECT_OPTION_EDITABILITY_GUIDANCE } from '../shared/editability-boundary';
 import { MetadataProtectionFields } from '../kernel/metadata-protection.zod';
 import { SystemIdentifierSchema } from '../shared/identifiers.zod';
-import { ExpressionInputSchema } from '../shared/expression.zod';
+import { ExpressionInputSchema, PredicateInputSchema } from '../shared/expression.zod';
 import { FilterConditionSchema } from './filter.zod';
 import { FIELD_KEY_GUIDANCE } from './authoring-key-lint';
 import { DEFAULT_AUTONUMBER_FORMAT } from './autonumber-format';
@@ -1639,10 +1639,25 @@ export const FieldSchema = lazySchema(() => {
    * state live as the record changes (UX), and the server enforces
    * `requiredWhen` and ignores writes to a field whose `readonlyWhen` is TRUE
    * (so the rule can't be bypassed). e.g. `P\`record.status == 'paid'\``.
+   *
+   * These three are THE field-rule triad, and they are EVALUATED slots: they
+   * compose `PredicateInputSchema` (ADR-0136 D1), not the persistence
+   * `ExpressionInputSchema`, so an envelope carrying only an `ast` and a
+   * `source` that is blank after trimming are refused HERE, at authoring,
+   * instead of faulting at evaluation. A blank predicate is the triad's third
+   * state — not "no rule" and not "engine fault" — and refusing it at
+   * authoring is what keeps those two apart at runtime.
+   *
+   * What happens when one of these DOES fault (a stored rule, a column renamed
+   * out from under it) is contract, not renderer choice: the submit is refused
+   * loudly and names the field and the rule (ADR-0136 D2), while visibility
+   * stays fail-OPEN at render so a rule that could not run never hides a
+   * control and writes `null` over a column the user never saw (D3). The two
+   * directions are a pair; neither is safe alone.
    */
-  visibleWhen: ExpressionInputSchema.optional().describe("Predicate (CEL) — field is shown only when TRUE (else hidden). e.g. P`record.type == 'invoice'`"),
-  readonlyWhen: ExpressionInputSchema.optional().describe("Predicate (CEL) — field is read-only when TRUE. e.g. P`record.status == 'paid'`"),
-  requiredWhen: ExpressionInputSchema.optional().describe("Predicate (CEL) — field is required when TRUE. A TRANSITION GATE, not an invariant: the write is refused only when the merged record violates the requirement AND the pre-write record complied — so the write that flips the predicate TRUE, an INSERT born inside the gate, and a write that clears the cell are all refused, while a row that was already missing the value keeps passing unrelated edits and state moves that stay inside the gate (ADR-0113 non-regression: adding the rule to a deployed object never bricks existing rows). Need an invariant every write must satisfy instead ('X may never exceed Y') — declare a `validations[]` `script` rule, which re-checks the merged record with no exemption. Enforced by `evaluateValidationRules`. The only slot; the `conditionalRequired` alias was removed in protocol 17."),
+  visibleWhen: PredicateInputSchema.optional().describe("Predicate (CEL) — field is shown only when TRUE (else hidden). Needs a non-blank `source`: an evaluated slot is held to what the engine can run (ADR-0136 D1). A fault at RENDER is fail-open (the field shows) and refuses the SUBMIT, naming the field and this rule (D2/D3). e.g. P`record.type == 'invoice'`"),
+  readonlyWhen: PredicateInputSchema.optional().describe("Predicate (CEL) — field is read-only when TRUE. Needs a non-blank `source` (ADR-0136 D1); a fault refuses the submit and names the field and this rule (D2). e.g. P`record.status == 'paid'`"),
+  requiredWhen: PredicateInputSchema.optional().describe("Predicate (CEL) — field is required when TRUE. Needs a non-blank `source` (ADR-0136 D1); a fault refuses the submit and names the field and this rule (D2). A TRANSITION GATE, not an invariant: the write is refused only when the merged record violates the requirement AND the pre-write record complied — so the write that flips the predicate TRUE, an INSERT born inside the gate, and a write that clears the cell are all refused, while a row that was already missing the value keeps passing unrelated edits and state moves that stay inside the gate (ADR-0113 non-regression: adding the rule to a deployed object never bricks existing rows). Need an invariant every write must satisfy instead ('X may never exceed Y') — declare a `validations[]` `script` rule, which re-checks the merged record with no exemption. Enforced by `evaluateValidationRules`. The only slot; the `conditionalRequired` alias was removed in protocol 17."),
 
   /**
    * [REMOVED in protocol 17 — #3855] The deprecated alias of `requiredWhen`.
 
@@ -395,13 +395,74 @@ export type TemplateExpressionInput = z.input<typeof TemplateExpressionInputSche
 
 /**
  * Predicate — an Expression whose evaluation is expected to be boolean.
- * Spec layer cannot enforce return type at parse time; this alias exists for
- * intent documentation and future runtime type-check wiring.
+ * Spec layer cannot enforce return type at parse time; this alias carries the
+ * intent, and since ADR-0136 it also carries the one thing the spec layer CAN
+ * enforce about a predicate: that the engine can run it at all.
+ *
+ * ## A predicate is an EVALUATED slot, by definition (ADR-0136 D1)
+ *
+ * These two composed {@link ExpressionSchema} / {@link ExpressionInputSchema}
+ * — the PERSISTENCE contract, whose rule is "`source` OR `ast`" — for as long
+ * as the alias was only intent documentation. That was the defect, not the
+ * documentation: a predicate exists to be EVALUATED, so the envelope it accepts
+ * has to be one the engine can evaluate, and the engine reads `source` alone
+ * (`cel-engine.ts` `evaluate`: "AST-only evaluation not yet supported; persist
+ * `source`"). An `ast`-only envelope and a `source` that is blank after
+ * trimming both parsed here, registered, passed `objectstack validate`, and
+ * then faulted or short-circuited at evaluation time — declared, never
+ * enforced. So these compose {@link EvaluatedExpressionSchema} /
+ * {@link EvaluatedExpressionInputSchema} and refuse both spellings at
+ * authoring, with the published sentence
+ * {@link EVALUATED_EXPRESSION_SOURCE_REQUIRED}.
+ *
+ * `ExpressionSchema` / `ExpressionInputSchema` are NOT narrowed: they remain
+ * the persistence contract. This is the same move `FlowEdgeSchema.condition`
+ * made, one rule reaching a second family of slots rather than a second rule.
+ *
+ * ## The fault semantics this contract declares (ADR-0136 D2–D4)
+ *
+ * A predicate has THREE states, not two, and each has a declared consequence.
+ * The states are "absent", "authored", and "authored but not evaluable" —
+ * and a BLANK predicate is the third, never the first: it is refused at
+ * authoring by the rule above, and where one is already stored it takes the
+ * fault path, never a silent pass.
+ *
+ *  - **At SUBMIT, a faulting field-rule predicate refuses the write, loudly,
+ *    naming the field and the rule** (D2). Nothing is persisted. A rule that
+ *    could not run has produced no verdict, and treating "no verdict" as the
+ *    author's verdict is what let one misspelled column show more, lock less
+ *    and demand less at once, with no state that said "this rule did not run".
+ *  - **At RENDER, visibility stays fail-OPEN** (D3). A faulting `visibleWhen`
+ *    SHOWS the field. This direction is load-bearing and is not a softening of
+ *    D2: hiding a control whose rule faulted is how a form comes to write
+ *    `null` over a column the user never saw, and the submit-time refusal is
+ *    what makes the pair safe. `readonlyWhen` / `requiredWhen` keep their
+ *    existing render directions for display.
+ *  - **A blank or faulting GATE predicate is diagnosed, never a silent `true`**
+ *    (D4) — the action / visibility gate path, which answered a bare `true`
+ *    for a blank source before it ever reached the evaluator.
+ *
+ * D2–D4 are consequences a CONSUMER delivers — the renderer, the submit path,
+ * the gate evaluator — and `packages/spec` carries no business logic
+ * (Prime Directive #2). They are declared here because the declaration is the
+ * contract those consumers are held to, and because a consumer cannot be held
+ * to a direction no protocol states. What this file ENFORCES is the authoring
+ * refusal above.
+ *
+ * ## What this contract deliberately does NOT do
+ *
+ * It does not bake a fault direction into the evaluation HELPER. The helper's
+ * fallback stays freely specifiable, because two shipped strategies depend on
+ * that freedom — fault-to-flag (asking `true` and `false` and diffing the
+ * answers) and fault-to-throw (a caller that wants the fault to propagate).
+ * A contract that fixed the helper's fallback would delete both. The direction
+ * is declared at the field-rule and gate layer, which is where the author's
+ * intent lives; the helper stays a mechanism.
  */
-export const PredicateSchema = ExpressionSchema;
+export const PredicateSchema = EvaluatedExpressionSchema;
 export type Predicate = z.input<typeof PredicateSchema>;
 
-export const PredicateInputSchema = ExpressionInputSchema;
+export const PredicateInputSchema = EvaluatedExpressionInputSchema;
 export type PredicateInput = z.input<typeof PredicateInputSchema>;
 
 /**