test(service-automation): re-judge the absent-branch registration pin; reconcile required over the predicate role (#19961)

Claude-Session: https://claude.ai/code/session_01Rjy9MeetSfq34PKn81CRiN
Co-authored-by: Claude <noreply@anthropic.com>

Author: claude

packages/services/service-automation/src/builtin/config-expression-ledger.test.ts

@@ -227,14 +227,24 @@ describe('configSchema ↔ expression-ledger reconciliation (#4027)', () => {
    * contract does not back would refuse a legal omission (an absent
    * `visibleWhen` shows the field); a requirement the ledger misses is the
    * #19961 shape again — declared required, admitted absent at every door.
+   *
+   * Reconciled over the `predicate` role, the one role the flag acts on: the
+   * resolver emits an absent value only for a required PREDICATE slot. The
+   * channels require two `flow-template` slots too (`loop.collection`,
+   * `map.collection`), and no door refuses their absence — their executors
+   * parse their own config — so the flag stays off there, and the second
+   * assertion pins that it is never set on another role.
    */
-  it('the ledger marks `required` exactly the slots the declaring channel requires (#19961)', () => {
-    const declared = declaredEverywhere();
+  it('the ledger marks `required` exactly the predicate slots the declaring channel requires (#19961)', () => {
+    const declared = declaredEverywhere().filter((d) => d.role === 'predicate');
     const requiredByChannel = declared.filter((d) => d.required).map(key).sort();
-    const requiredByLedger = FLOW_NODE_EXPRESSION_PATHS.filter((e) => e.required).map(key).sort();
+    const requiredByLedger = FLOW_NODE_EXPRESSION_PATHS.filter((e) => e.role === 'predicate' && e.required).map(key).sort();
     expect(requiredByLedger, 'ledger `required` flags disagree with the declaring channel').toEqual(requiredByChannel);
-    // Non-vacuous: the one required slot there is today is derived, not assumed.
+    expect(FLOW_NODE_EXPRESSION_PATHS.filter((e) => e.role !== 'predicate' && e.required).map(key), '`required` acts on the predicate role only').toEqual([]);
+    // Non-vacuous: the one required predicate slot there is today is derived,
+    // not assumed — and the optional one (`visibleWhen`) is derived as optional.
     expect(requiredByChannel).toEqual(['decision.conditions[].expression (predicate)']);
+    expect(declared.filter((d) => !d.required).map(key)).toEqual(['screen.fields[].visibleWhen (predicate)']);
   });
 
   it('decision.conditions[].expression is covered — the #4439 hole', () => {

packages/services/service-automation/src/decision-predicate-envelope.test.ts

@@ -121,11 +121,23 @@ describe('decision branch predicate — envelope in a `z.string()` slot (#15572)
      * string is now refused here too — by `FlowSchema.parse` inside
      * `registerFlow`, under this slot's own sentence. A non-blank string and an
      * absent predicate still register, exactly as this test always said.
+     *
+     * RE-JUDGED IN PLACE AGAIN (#19961) — the absent half. It pinned
+     * `decisionFlow('str_absent', undefined)` as registering: "an absent
+     * predicate still registers". That was "not authored" on the resolver's
+     * side only. `DecisionConditionSchema` declares `expression` a REQUIRED
+     * `z.string()`, and the executor evaluates every branch it reaches, so a
+     * branch with no `expression` failed the run at the branch — the build
+     * accepted what the run refused. The ledger now marks the slot `required`
+     * and the absent value is refused through the same `predicateSlotRefusal`
+     * as the blank, under the same sentence, with its own detail.
      */
-    it('leaves non-blank string predicates alone — and refuses the whitespace-only one (#17493)', () => {
+    it('leaves non-blank string predicates alone — and refuses the whitespace-only one (#17493) and the absent one (#19961)', () => {
         expect(() => engine.registerFlow('str_ok', decisionFlow('str_ok', 'record.rating >= 4'))).not.toThrow();
         expect(() => engine.registerFlow('str_ws', decisionFlow('str_ws', '   '))).toThrow(PREDICATE_SLOT_STRING_REFUSAL);
-        expect(() => engine.registerFlow('str_absent', decisionFlow('str_absent', undefined))).not.toThrow();
+        const absent = () => engine.registerFlow('str_absent', decisionFlow('str_absent', undefined));
+        expect(absent).toThrow(PREDICATE_SLOT_STRING_REFUSAL);
+        expect(absent).toThrow('Found nothing — the key is absent where the slot is required');
     });
 
     /**

packages/spec/src/automation/flow-node-expression-paths.ts

@@ -165,8 +165,11 @@ export interface FlowNodeExpressionPath {
    *
    * Reconciled against the channel's own `required` list by the ratchet that
    * reconciles the markers (`config-expression-ledger.test.ts` in
-   * `service-automation`), in both directions, so this flag cannot claim a
-   * requirement the contract does not make, nor miss one it does.
+   * `service-automation`), in both directions over the `predicate` role, so
+   * this flag cannot claim a requirement the contract does not make, nor miss
+   * one it does. Never set on another role: the channels require
+   * `loop.collection` / `map.collection` too, but no door refuses their
+   * absence — their executors parse their own config.
    */
   readonly required?: true;
 }