feat(devx): reach the INLINE literal expression at an object-literal code: (#14625)

The vocabulary gate reached a `code:` whose value is a quoted literal
(`objlit`), a SCREAMING_SNAKE constant (`objlitconst`), a template
(`objlittemplate`) or a helper parameter (`objlithelper`), but not an INLINE
literal EXPRESSION — a ternary or a `||`/`??` chain written at the stamp with
every branch already a literal. That is no site AND no unresolved: the one way
the gate's "REPORTED as unresolved, never dropped" bound cannot notice itself
failing, in a third stamp position.

Adds the fifth object-literal shape, `objlitexpr`. It needs no resolver —
`literalCodeValues` reduces the value text between `code:` and the property's
terminating top-level comma directly, and `resolveIdent` is left at its default
so an identifier limb keeps the expression unreducible, which is what keeps this
shape out of the lower-case-LOCAL position that stays censused and open.

Precision measured BEFORE implementing, over the gate's own population: of 902
`code:` tokens the shape reaches 346, three guards reject 130, 216 reach the
reduction and 214 decline — including every type annotation — leaving 2 live
positions, 5 values, 2 verdict rows and 0 unregistered wire codes hiding. The
ALL-OR-NOTHING reduction IS the guard against the type-annotation noise the
helper position pays per value stamp. Frozen in
INLINE_LITERAL_EXPRESSION_CENSUS, printed in the bounds line, arithmetic pinned.

The two rows the widening owes land in the same commit, after the widening,
because the reconciliation runs in both directions: the ADR-0112 D6
field-addressed validation catalog in `domains/automation.ts`. They are reported
here rather than delegated to check:error-code-casing because that gate needs a
quoted literal beside the token `code` and an inline ternary has none —
measured, and pinned against its real detector.


Claude-Session: https://claude.ai/code/session_01WLJQhde67SeTccsmnBVarV

Co-authored-by: Claude <noreply@anthropic.com>

Author: claude[bot]

packages/runtime/src/dispatcher-error-vocabulary.ts

@@ -134,7 +134,32 @@ export type CodeStampShape =
      * because a filter drawn around the inconvenient cases is an exemption
      * wearing a predicate's clothes.
      */
-    | 'objlithelper';
+    | 'objlithelper'
+    /**
+     * [#13790] An INLINE literal EXPRESSION at an object-literal `code:` — a
+     * ternary, or a `||`/`??` chain, written at the stamp itself with every
+     * branch already a literal:
+     *
+     * ```ts
+     * code: isProvisioning ? 'PROJECT_PROVISIONING' : 'PROJECT_NOT_FOUND'
+     * ```
+     *
+     * The fifth object-literal position and, until #13790, the third one no
+     * shape reached at all: `objlit` needs the quote immediately after the
+     * colon and here the condition comes first, `objlitconst` needs a
+     * SCREAMING_SNAKE identifier there, `objlittemplate` needs backticks, and
+     * `objlithelper`'s candidate captures the CONDITION's identifier, which is
+     * not a parameter, so it declines. No site AND no unresolved, again.
+     *
+     * ⭐ Unlike every other indirect shape it needs NO resolver: the gate
+     * reduces the value text with `literalCodeValues` directly, and the
+     * ALL-OR-NOTHING rule that drops an expression with one runtime limb is
+     * also what keeps its precision high — 214 of the 216 candidate positions
+     * on the tree it landed against are type annotations or runtime
+     * expressions, and every one of them reduces to nothing without a single
+     * position-specific test.
+     */
+    | 'objlitexpr';
 
 /**
  * Where the stamped code can end up. `dispatcher` is the door this card is
@@ -1180,6 +1205,62 @@ export const UNREGISTERED_CODE_SITES: readonly UnregisteredCodeSite[] = [
             'It reaches `ApiError.details.fields[].code`, never `error.code`, so no ledger row can be owed ' +
             'for it (ADR-0112 D6).',
     },
+
+    // ── [#13790] the SAME D6 genre, arriving through the inline-expression ──
+    // ── shape rather than through a helper parameter ────────────────────────
+    //
+    // These two rows are the whole verdict cost of the `objlitexpr` widening on
+    // this tree, and they are owed for the reason the block above is owed:
+    // reconciliation runs in BOTH directions, so a newly derived site with no
+    // row is a red. What is NOT here is the point of the card — no
+    // `pending-registration` row, because the widening surfaced no unregistered
+    // WIRE code at all. The other live inline-expression position,
+    // `packages/rest/src/error-response.ts`, stamps `PROJECT_PROVISIONING` /
+    // `PROJECT_PROVISIONING_FAILED` / `PROJECT_NOT_FOUND` — all three already in
+    // `ERROR_CODE_LEDGER`, so the scan derives no site for them, and the value
+    // of the shape there is that it will derive one the day a fourth branch is
+    // added to that ternary. That file is the REST door itself.
+    //
+    // ⚠️ Reported HERE rather than delegated to `check:error-code-casing`, and
+    // that was measured rather than assumed. Every pattern that gate has needs
+    // a QUOTED literal beside the token `code`; at an inline ternary there is
+    // none — `findViolations()` returns ZERO findings for this file, while the
+    // literally-spelled `code: 'invalid_type'` a few lines up it DOES see and
+    // correctly skips as D6. A `casing-gate` delegation here would therefore be
+    // the seam this file's header describes, not a hand-off.
+    // flow definition + clone doors — domains/automation.ts
+    {
+        code: 'required',
+        file: 'packages/runtime/src/domains/automation.ts',
+        shape: 'objlitexpr',
+        door: 'none',
+        verdict: 'foreign-vocabulary',
+        why:
+            'The automation door builds `validationFailure(message, [{ field, code, message }])` and stamps ' +
+            'the field code as an INLINE ternary at the property itself — `code: body.name === undefined ? ' +
+            '\'required\' : \'invalid_type\'`. Both branches are ADR-0114 D2 `FieldErrorCode` members, and ' +
+            '`validationFailure` puts the record in `ApiError.details.fields[]` while `error.code` carries ' +
+            'the envelope\'s own VALIDATION_ERROR. The same D6 field-addressed catalog the record-validator ' +
+            'and query-param rows above carry, one stamp shape over (ADR-0112 D6).',
+    },
+    {
+        code: 'invalid_type',
+        file: 'packages/runtime/src/domains/automation.ts',
+        shape: 'objlitexpr',
+        door: 'none',
+        verdict: 'foreign-vocabulary',
+        why:
+            'The automation door builds `validationFailure(message, [{ field, code, message }])` and stamps ' +
+            'the field code as an INLINE ternary at the property itself — `code: body.name === undefined ? ' +
+            '\'required\' : \'invalid_type\'`. Both branches are ADR-0114 D2 `FieldErrorCode` members, and ' +
+            '`validationFailure` puts the record in `ApiError.details.fields[]` while `error.code` carries ' +
+            'the envelope\'s own VALIDATION_ERROR. The same D6 field-addressed catalog the record-validator ' +
+            'and query-param rows above carry, one stamp shape over (ADR-0112 D6). ⚠️ The gate derives this ' +
+            'row from the `name` ternary alone: two more instances of the identical stamp (the clone door\'s ' +
+            '`name` and `label` checks) sit behind a nested-template desync in the shared textual scanners ' +
+            'and are invisible to `enclosingOpeners`. Same values, same verdict; recorded so the count is ' +
+            'read as a lower bound.',
+    },
 ];
 
 /**