@@ -2128,9 +2128,10 @@ export type AuthoringRuleFinding = AuthoringAdvisory;
  *
  * The `hint` line is conditional, which is how `printAuthoringAdvisories` and
  * `init` already rendered it; `compile`/`validate` printed it unconditionally.
- * `AuthoringFinding.hint` is a required non-empty string in every rule the
- * registry ships (checked: no rule emits an empty one), so the two forms
- * differ on no finding this CLI can actually produce.
+ * [#22161] The condition is now load-bearing: `hint` prints as the `fix:`
+ * line, and `expression-invalid` emits an empty one — its finding carries no
+ * fix of its own, and the authored source it used to put there is a quote,
+ * which rides the message instead.
  */
 export function printAuthoringRuleErrors(
   errors: readonly AuthoringRuleFinding[],
 
@@ -27,6 +27,8 @@ import { afterEach, describe, expect, it, vi } from 'vitest';
 
 import * as lint from '@objectstack/lint';
 import {
+  AUTHORING_RULES,
+  EXPRESSION_INVALID,
   FIELD_NO_CONSUMERS,
   RULE_EXPLANATIONS,
   SECURITY_OWD_UNSET,
@@ -220,4 +222,44 @@ describe('the printed shape of each shortened rule — verdict, fix, rule line w
       .toEqual(['fix: Remove it.', 'rule: liveness-dead-property  at views[0].name']);
     expect(authoringFindingDetailLines({ rule: 'some-rule', path: 'p' })).toEqual(['rule: some-rule  at p']);
   });
+
+  // The `fix:` label is only true of a hint that IS a fix. `expression-invalid`
+  // used to put the authored source in `hint`, which printed as
+  // `fix: source: \`status != "resolved"\`` — the expression the author already
+  // wrote, offered as the fix. The source is a quote: it rides the verdict, so
+  // it still reaches the text face (and the runtime 422 issue's `message`).
+  it('expression-invalid: the authored source rides the verdict, and no `fix: source:` line is printed', async () => {
+    const entry = AUTHORING_RULES.find((r) => r.name === 'validateStackExpressions');
+    expect(entry, 'the registry entry that adapts ExprIssue into expression-invalid').toBeDefined();
+    const [finding] = entry!.run(
+      {
+        objects: [
+          {
+            name: 'my_app_ticket',
+            fields: {
+              title: { type: 'text' },
+              status: { type: 'select', options: [{ label: 'Open', value: 'open' }, { label: 'Resolved', value: 'resolved' }] },
+            },
+          },
+        ],
+        actions: [
+          { name: 'resolve_ticket', label: 'Resolve', objectName: 'my_app_ticket', type: 'script', visible: 'status != "resolved"' },
+        ],
+      },
+      {},
+    );
+    expect(finding?.rule).toBe(EXPRESSION_INVALID);
+    expect(finding.message).toContain('Write `record.status`');
+    expect(finding.message).toMatch(/ — source: `status != "resolved"`$/);
+    expect(finding.hint).toBe('');
+
+    const out = await captureStdout(() => printAuthoringRuleErrors([finding]));
+    const lines = out.split('\n').filter((l) => l.trim() !== '');
+    expect(lines).toHaveLength(2);
+    expect(lines[0]).toBe(`  • ${finding.where}: ${finding.message}`);
+    expect(lines[0]).toContain('source: `status != "resolved"`');
+    expect(lines[1]).toBe(`      rule: expression-invalid  at ${finding.path}`);
+    expect(out).not.toMatch(/fix: source:/);
+    expect(out).not.toMatch(/^\s*fix:/m);
+  });
 });
@@ -683,8 +683,15 @@ export const AUTHORING_RULES: readonly AuthoringRule[] = [
         rule: EXPRESSION_INVALID,
         where: i.where,
         path: i.where,
-        message: i.message,
-        hint: `source: \`${i.source}\``,
+        // [#22161] The authored source is a QUOTE of what the author wrote, not
+        // a fix, so it rides the verdict — `— source: \`…\`` is the spelling
+        // the flow engine's runtime refusals already use — and reaches the CLI
+        // text face and the runtime 422 issue alike. `hint` is the `fix:` line:
+        // an `ExprIssue` carries no fix of its own (its message prescribes the
+        // rewrite where there is one, e.g. "Write `record.status`"), so there is
+        // none to print rather than a quote dressed as one.
+        message: i.source.trim() ? `${i.message} — source: \`${i.source}\`` : i.message,
+        hint: '',
       })),
   },
   // ADR-0053 — `userFilters`/`quickFilters` on an object list view ("views"
 
@@ -244,7 +244,11 @@ function describe(entry: LedgerEntry): { kind: string; rule: string; defaultHint
     return {
       kind: 'is experimental — declared but NOT enforced at runtime',
       rule: LIVENESS_EXPERIMENTAL_PROPERTY,
-      defaultHint: 'It is declared in the spec as an experimental guarantee — not yet enforced at runtime.',
+      // [#22161] The CLI prints `hint` as the `fix:` line, so it says what to
+      // do; the fact it used to state alone is the reason.
+      defaultHint:
+        'Do not rely on it as a guarantee: it is declared in the spec as an experimental guarantee and ' +
+        'not yet enforced at runtime.',
     };
   }
   if (entry.status === 'planned') {
 
@@ -332,12 +332,17 @@ export function validateComponentProps(stack: AnyRec): ComponentPropsFinding[] {
           rule: COMPONENT_PROPS_INVALID,
           where,
           path: at,
-          message: `${at.slice(base.length + 1) || 'properties'}: ${describeIssue(issue, props)}`,
+          // [#22161] `hint` is the CLI's `fix:` line, so it states the fix; the
+          // advisory posture it used to explain (judged here as a warning, and
+          // the props bag is not parsed on the storage path) is the verdict's
+          // consequence and rides the message.
+          message:
+            `${at.slice(base.length + 1) || 'properties'}: ${describeIssue(issue, props)} — ` +
+            'nothing refuses it today, so the renderer receives the props as written',
           hint:
-            `\`${type}\`'s props are declared by ComponentPropsMap (@objectstack/spec/ui) — the ` +
-            'rejection above carries the fix. Advisory for now: props are judged here, at the authoring ' +
-            'door, as a warning before they become an error, and the props bag is not parsed on the ' +
-            'storage path either, so nothing rejects this today.',
+            `Give \`${type}\` props its schema accepts (ComponentPropsMap, @objectstack/spec/ui) — the ` +
+            'rejection above names what it expects — or, if the component really does honour what is ' +
+            'written, correct the schema so the declaration and the renderer agree.',
         });
       }
     }
 
@@ -494,10 +494,13 @@ export function validateFlowTriggerReadiness(stack: AnyRec): FlowTriggerReadines
             `has a config.timeRelative descriptor the time-relative trigger REFUSES at bind time, so the ` +
             `sweep is never installed — the flow declares a time-relative trigger and then never runs ` +
             `(the only trace is one warn in the server log). ${problems}`,
+          // [#22161] `hint` is the CLI's `fix:` line: the instruction first, the
+          // reason it is sufficient after it.
           hint:
-            `Those messages are TimeRelativeTriggerSchema's own — the same schema the trigger safeParses at ` +
-            `bind time, so a descriptor that satisfies them binds. An unrecognized key names the declared key ` +
-            `it was probably meant to be; see content/docs/references/automation/time-relative-trigger.mdx.`,
+            `Correct config.timeRelative until it satisfies each message above: they are ` +
+            `TimeRelativeTriggerSchema's own, the same schema the trigger safeParses at bind time, so a ` +
+            `descriptor that satisfies them binds. An unrecognized key names the declared key it was ` +
+            `probably meant to be; see content/docs/references/automation/time-relative-trigger.mdx.`,
         });
       }
     }
 
@@ -1163,9 +1163,15 @@ export function validateReactPageProps(stack: AnyRec): ReactPropFinding[] {
                   : `<${tag}> is missing the required prop "${req}".`,
                 // The contract's own description of the binding says how to
                 // write it — the author gets the spelling, not a pointer.
+                // [#22161] `hint` is the CLI's `fix:` line, and a description
+                // alone ("The registered component type to render.") is not a
+                // fix: the instruction leads, the description follows it.
                 hint: dep
                   ? dep.note
-                  : block.requiredDescriptions.get(req) ?? `Pass ${req}={…}. See the react-tier component contract.`,
+                  : `Pass ${req}={…}` +
+                    (block.requiredDescriptions.has(req)
+                      ? `: ${block.requiredDescriptions.get(req)}`
+                      : '. See the react-tier component contract.'),
               });
             }
           }