@@ -3006,7 +3006,8 @@ const TRANSLATION_TARGET_UNKNOWN_EXPLANATION: RuleExplanation = {
       'line names the remedy only, without listing what is declared; what each key may name follows.',
     'Under `objects.OBJECT` (an object this stack, or a sibling package of the same artifact, ' +
       'defines): `fields.FIELD` a declared field (a system column, `_id`, `name` and `space` are ' +
-      'never reported); `_views.VIEW` a view\'s `name`, not its label; `_sections.KEY` a ' +
+      'never reported); `_views.VIEW` a view\'s `name`, not its label — the runtime keys a nameless ' +
+      'default `list` `default`, never `list`; `_sections.KEY` a ' +
       '`fieldGroups[].key`, a named form-view section or a named `record:details` section — a ' +
       'section is translatable only through a stable name; `_tabs.TAB` a filter-preset tab that a ' +
       'page over the object declares in `interfaceConfig.userFilters.tabs` (a list view\'s own ' +
 
@@ -13,7 +13,7 @@ import { explainRule } from './rule-explanations.js';
 // verdict to one line of at most 200 characters — every firing variant this
 // suite exercises, not a chosen few. Run the whole file: those cases read what
 // the cases above fired.
-const fired: Array<{ rule: string; message: string }> = [];
+const fired: Array<{ rule: string; message: string; hint: string }> = [];
 const validateAiSurfaceAffinity: typeof validateAiSurfaceAffinityUnrecorded = (...args) => {
   const findings = validateAiSurfaceAffinityUnrecorded(...args);
   fired.push(...findings);
@@ -196,3 +196,30 @@ describe('[#22161] one-line verdicts — ai-skill-surface-mismatch', () => {
     }
   });
 });
+
+// [#22161] Slice 16: the `fix:` line names the three ways out in one line; when
+// `surface: 'both'` is right is the explanation's.
+describe('[#22161] one-line fix — ai-skill-surface-mismatch', () => {
+  it('reads as one remedy, a long skill name included, at most 200 characters', () => {
+    const ref = 'regional_enterprise_pipeline_forecast_reviewer';
+    const [f] = validateAiSurfaceAffinity({
+      agents: [{ name: 'sales_assistant', surface: 'ask', skills: [ref] }],
+      skills: [{ name: ref, surface: 'build' }],
+    });
+    expect(f!.hint).toBe(
+      `Move "${ref}" to a 'build'-surface agent, change its \`surface\` to 'ask', or declare \`surface: 'both'\` ` +
+        'for a shared, read-only skill',
+    );
+    const converted = fired.filter((x) => x.rule === AI_SKILL_SURFACE_MISMATCH);
+    expect(converted.length).toBeGreaterThan(1);
+    for (const x of converted) {
+      expect(x.hint, x.rule).not.toContain('\n');
+      expect(x.hint.length, `${x.rule}: ${x.hint}`).toBeLessThanOrEqual(200);
+    }
+  });
+
+  it('`os explain` carries what the `fix:` line no longer says', () => {
+    const text = explainRule(AI_SKILL_SURFACE_MISMATCH)!.paragraphs.join('\n');
+    expect(text).toContain("Declare `surface: 'both'` only for a genuinely shared, read-only capability");
+  });
+});
@@ -2,6 +2,7 @@
 
 import { describe, it, expect } from 'vitest';
 import { BUILTIN_MEMBERSHIP_ROLES } from '@objectstack/spec';
+import { APPROVER_EXPRESSION_ROOTS, ApprovalNodeConfigSchema } from '@objectstack/spec/automation';
 import {
   validateApprovalApprovers as validateApprovalApproversUnrecorded,
   APPROVAL_APPROVER_NOT_MEMBERSHIP_TIER,
@@ -856,3 +857,127 @@ describe('[#22161] one-line fixes — approval-approvers-may-resolve-empty, agai
     expect(text).toContain("only an organization with no administrator leaves the request on an empty");
   });
 });
+
+// [#22161] Slice 16: the `fix:` lines of the other three `approval-*` ids. Each
+// names its remedy in one line; what each root holds, why `record` is unbound,
+// what each empty-slate policy does and why a business role is a position are
+// the explanations'. The bound reads every finding the cases above fired.
+describe('[#22161] one-line fixes — the expression and membership-tier ids', () => {
+  const SLICE_16 = [
+    APPROVAL_APPROVER_NOT_MEMBERSHIP_TIER,
+    APPROVAL_EXPRESSION_INVALID,
+    APPROVAL_EXPRESSION_NO_EMPTY_POLICY,
+  ];
+  const stackWithConfig = (config: Record<string, unknown>): Record<string, unknown> => ({
+    flows: [{
+      name: 'expense_approval',
+      nodes: [
+        { id: 'start', type: 'start', config: {} },
+        { id: 'step1', type: 'approval', config },
+      ],
+      edges: [],
+    }],
+  });
+
+  it('every `fix:` line of the three ids the cases above fired is one line of at most 200 characters', () => {
+    // A long position name, so the bound is not read on short names alone.
+    validateApprovalApprovers(stackWithApprovers([
+      { type: 'org_membership_level', value: 'regional_vice_president_of_enterprise_sales' },
+    ]));
+    const converted = fired.filter((f) => SLICE_16.includes(f.rule));
+    // Coverage control: every arm of the three ids fired.
+    expect(converted.some((f) => f.rule === APPROVAL_APPROVER_NOT_MEMBERSHIP_TIER)).toBe(true);
+    expect(converted.some((f) => f.rule === APPROVAL_EXPRESSION_NO_EMPTY_POLICY)).toBe(true);
+    const invalid = converted.filter((f) => f.rule === APPROVAL_EXPRESSION_INVALID);
+    for (const arm of ['empty expression', 'does not parse', 'references `record`', 'references `approvers_dynamic`', 'resolveAs has no effect']) {
+      expect(invalid.some((f) => f.message.includes(arm)), arm).toBe(true);
+    }
+    for (const f of converted) {
+      expect(f.hint, f.rule).not.toContain('\n');
+      expect(f.hint.length, `${f.rule}: ${f.hint}`).toBeLessThanOrEqual(200);
+    }
+  });
+
+  it('each arm reads as one remedy', () => {
+    const [tier] = validateApprovalApprovers(stackWithApprovers([{ type: 'org_membership_level', value: 'sales_manager' }]));
+    expect(tier.hint).toBe(
+      "If it is an org position, author { type: 'position', value: 'sales_manager' }; keep " +
+        "'org_membership_level' for the tiers the verdict lists",
+    );
+    const [empty] = validateApprovalApprovers(stackWithConfig({
+      approvers: [{ type: 'expression', value: '' }],
+      onEmptyApprovers: 'fail',
+    }));
+    expect(empty.hint).toBe('Write a CEL expression over current.*, trigger.* or vars.*, e.g. current.approvers_dynamic');
+    const [record] = validateApprovalApprovers(stackWithConfig({
+      approvers: [{ type: 'expression', value: 'record.owner_id' }],
+      onEmptyApprovers: 'fail',
+    }));
+    expect(record.hint).toBe(
+      'Write current.<field> for the live value at node entry or trigger.<field> for the submit-time ' +
+        'snapshot; vars.previous carries the pre-update row',
+    );
+    const [nudge] = validateApprovalApprovers(stackWithConfig({
+      approvers: [{ type: 'expression', value: 'vars.picked' }],
+    }));
+    expect(nudge.hint).toBe(
+      "Declare onEmptyApprovers on the node: 'admin_rescue', 'fail', 'auto_approve', or 'fallback' " +
+        'with a fallbackApprovers list',
+    );
+  });
+
+  it("the nudge's policies and the explanation's are the spec's `onEmptyApprovers` enum", () => {
+    // The explanation module imports nothing, so it spells the list out; this
+    // holds both it and the fix line to the schema.
+    const policies = (
+      ApprovalNodeConfigSchema.shape.onEmptyApprovers.unwrap() as unknown as { options: readonly string[] }
+    ).options;
+    expect([...policies].sort()).toEqual(['admin_rescue', 'auto_approve', 'fail', 'fallback']);
+    const [nudge] = validateApprovalApprovers(stackWithConfig({
+      approvers: [{ type: 'expression', value: 'vars.picked' }],
+    }));
+    const text = explainRule(APPROVAL_EXPRESSION_NO_EMPTY_POLICY)!.paragraphs.join('\n');
+    for (const policy of policies) {
+      expect(nudge.hint, policy).toContain(`'${policy}'`);
+      expect(text, policy).toContain(`\`${policy}\``);
+    }
+  });
+
+  it("the explanation's expression roots are the spec's `APPROVER_EXPRESSION_ROOTS`", () => {
+    const text = explainRule(APPROVAL_EXPRESSION_INVALID)!.paragraphs.join('\n');
+    expect(APPROVER_EXPRESSION_ROOTS.length).toBe(3);
+    for (const root of APPROVER_EXPRESSION_ROOTS) expect(text, root).toContain(`\`${root}.*\``);
+  });
+
+  it('`os explain` carries what the three `fix:` lines no longer say', () => {
+    const facts: Record<string, string[]> = {
+      [APPROVAL_EXPRESSION_INVALID]: [
+        "record's live state at node entry",
+        'the submit-time snapshot',
+        'no `{…}` template braces',
+        'record at event time',
+        '`vars.previous` carries the pre-update row',
+        'fails the node at entry',
+        '`resolveAs` means something only on an `expression` approver',
+      ],
+      [APPROVAL_EXPRESSION_NO_EMPTY_POLICY]: [
+        "the organization's administrators",
+        'its fault edge',
+        '`output.autoApproved = true`',
+        '`fallbackApprovers`',
+        'degrades to `admin_rescue`',
+      ],
+      [APPROVAL_APPROVER_NOT_MEMBERSHIP_TIER]: [
+        'A business role is always a position',
+        '`sys_user_position`',
+        'ADR-0108',
+      ],
+    };
+    for (const [rule, list] of Object.entries(facts)) {
+      const entry = explainRule(rule);
+      expect(entry, `no \`os explain ${rule}\` entry`).toBeDefined();
+      const text = entry!.paragraphs.join('\n');
+      for (const fact of list) expect(text, `${rule} explanation names ${fact}`).toContain(fact);
+    }
+  });
+});
@@ -460,7 +460,7 @@ export function validateApprovalApprovers(stack: AnyRec): ApprovalApproverFindin
             // and why a business role is always a position (the closed
             // ADR-0108 vocabulary, `sys_user_position`) is the explanation's.
             hint:
-              `If '${value}' is an org position, author { type: 'position', value: '${value}' }; keep ` +
+              `If it is an org position, author { type: 'position', value: '${value}' }; keep ` +
               `'org_membership_level' for the tiers the verdict lists`,
           });
         } else if (type in DEPRECATED_APPROVER_TYPES) {
 
@@ -16,7 +16,7 @@ import { explainRule } from './rule-explanations.js';
 // verdict of those ids to one line of at most 200 characters — every position
 // and surface this suite exercises, not a chosen few. Run the whole file: those
 // cases read what the cases above fired.
-const fired: Array<{ rule: string; message: string; path: string }> = [];
+const fired: Array<{ rule: string; message: string; path: string; hint: string }> = [];
 const validateChartBindings: typeof validateChartBindingsUnrecorded = (...args) => {
   const findings = validateChartBindingsUnrecorded(...args);
   fired.push(...findings);
@@ -58,7 +58,9 @@ describe('validateChartBindings — report charts', () => {
     expect(findings[0].rule).toBe(CHART_MEASURE_UNKNOWN);
     expect(findings[0].path).toBe('reports[0].chart.yAxis');
     expect(findings[0].message).toContain('estimate_hours');
-    expect(findings[0].hint).toContain('est_hours');
+    // [#22161] The remedy alone: the dataset's measure list is no longer
+    // appended, and `estimate_hours` is no near miss of a declared measure.
+    expect(findings[0].hint).toBe('Bind a measure that dataset "task_metrics" declares, or declare "estimate_hours" on it.');
   });
 
   // #14577 — this rule used to carry a private Levenshtein-only `suggest`,
@@ -547,8 +549,11 @@ describe('validateChartBindings — binding vs presentation positions (#15575)',
     expect(findings[0].message).toContain('lands on nothing');
     expect(findings[0].message).not.toContain('comes back empty');
     // No surface here carries `suppressWarnings` (dashboard widgets only), and
-    // the hint says so rather than advertising a key that does not exist.
-    expect(findings[0].hint).toContain('no `suppressWarnings` key');
+    // nothing says otherwise: [#22161] the hint names the remedy alone, and the
+    // explanation says no key silences the advisory.
+    expect(findings[0].hint).toBe('Correct the name to a measure that dataset "task_metrics" declares, or drop the entry.');
+    expect(findings[0].hint).not.toContain('suppressWarnings');
+    expect(explainRule(CHART_MEASURE_UNKNOWN)!.paragraphs.join('\n')).toContain('carries a `suppressWarnings` key');
   });
 
   it('one report chart reports BOTH tiers — the query position gates, the presentation position advises', () => {
@@ -1160,3 +1165,48 @@ describe('[#22161] one-line verdicts — chart-measure-unknown, chart-axis-not-s
     expect(last(CHART_AXIS_NOT_SELECTED)).toBe(last(CHART_MEASURE_UNKNOWN));
   });
 });
+
+// [#22161] Slice 16: the `fix:` line of chart-measure-unknown. One remedy line
+// per position kind plus the nearest declared measure; the dataset's measure
+// list is no longer appended, and what each presentation position carries is
+// the explanation's.
+describe('[#22161] one-line fix — chart-measure-unknown', () => {
+  it('every `fix:` line the cases above fired is one line of at most 200 characters', () => {
+    const converted = fired.filter((f) => f.rule === CHART_MEASURE_UNKNOWN);
+    // Coverage control: a query position and every presentation position, a
+    // near miss and none.
+    for (const marker of ['comes back empty', 'DISPLAY-NAME override', 'REPLACES the authored array', 'axis PRESENTATION']) {
+      expect(converted.some((f) => f.message.includes(marker)), marker).toBe(true);
+    }
+    expect(converted.some((f) => f.hint.includes('Did you mean'))).toBe(true);
+    expect(converted.some((f) => !f.hint.includes('Did you mean'))).toBe(true);
+    for (const f of converted) {
+      expect(f.hint, f.rule).not.toContain('\n');
+      expect(f.hint.length, `${f.rule}: ${f.hint}`).toBeLessThanOrEqual(200);
+      expect(f.hint, f.rule).not.toContain('Dataset measures:');
+    }
+  });
+
+  it('keeps the nearest declared measure after the remedy', () => {
+    const [f] = validateChartBindings({
+      datasets: [{ name: 'sales_metrics', object: 'o', dimensions: [{ name: 'stage', field: 'stage' }], measures: [{ name: 'sum_amount', aggregate: 'sum', field: 'amount' }] }],
+      reports: [{ name: 'r', dataset: 'sales_metrics', values: ['sum_amount'], chart: { type: 'bar', xAxis: 'stage', yAxis: 'amount' } }],
+    });
+    expect(f!.hint).toBe(
+      'Bind a measure that dataset "sales_metrics" declares, or declare "amount" on it. Did you mean "sum_amount"?',
+    );
+  });
+
+  it('`os explain` carries what the presentation `fix:` line no longer says', () => {
+    const text = explainRule(CHART_MEASURE_UNKNOWN)!.paragraphs.join('\n');
+    for (const fact of [
+      'cannot add, remove or re-point one',
+      'membership belongs to the dataset selection',
+      'title, min/max, position, gridlines',
+      'carries a `suppressWarnings` key',
+      '"Did you mean"',
+    ]) {
+      expect(text, fact).toContain(fact);
+    }
+  });
+});
@@ -23,7 +23,7 @@ const SHORTENED_RULE_IDS: readonly string[] = [
   DATASET_FIELD_NOT_INCLUDED,
   DATASET_FILTER_FIELD_UNKNOWN,
 ];
-const firedShortened: Array<{ rule: string; message: string }> = [];
+const firedShortened: Array<{ rule: string; message: string; hint: string }> = [];
 const validateDatasetReferences: typeof validateDatasetReferencesUnrecorded = (...args) => {
   const findings = validateDatasetReferencesUnrecorded(...args);
   for (const f of findings) if (SHORTENED_RULE_IDS.includes(f.rule)) firedShortened.push(f);
@@ -609,3 +609,63 @@ describe('[#22161] one-line verdicts — the rule ids this file shortened', () =
     for (const fact of MOVED[rule]) expect(text, `${rule} explanation names ${fact}`).toContain(fact);
   });
 });
+
+// [#22161] Slice 16: the `fix:` lines of the include and field ids. Each is the
+// remedy alone: the verdict's "Did you mean" names the nearest field, so the
+// object's field list and the traversable types are no longer appended; the
+// three-hop limit and what joins are the explanation's.
+describe('[#22161] one-line fixes — dataset-include-unknown and dataset-field-unknown', () => {
+  const SLICE_16 = [DATASET_INCLUDE_UNKNOWN, DATASET_FIELD_UNKNOWN];
+
+  it('every `fix:` line of the two ids the cases above fired is one line of at most 200 characters', () => {
+    const converted = firedShortened.filter((f) => SLICE_16.includes(f.rule));
+    // Coverage control: every arm fired — an include entry that resolves to an
+    // ordinary field, one that names nothing, one whose hop is not a
+    // relationship; a dimension, a measure and a joined field path.
+    const include = converted.filter((f) => f.rule === DATASET_INCLUDE_UNKNOWN);
+    expect(include.some((f) => f.message.includes('not a relationship, so no join'))).toBe(true);
+    expect(include.some((f) => f.message.includes('Did you mean "duty"?'))).toBe(true);
+    expect(include.some((f) => f.message.includes('nothing to join through'))).toBe(true);
+    const field = converted.filter((f) => f.rule === DATASET_FIELD_UNKNOWN);
+    expect(field.some((f) => f.message.startsWith('dimension field'))).toBe(true);
+    expect(field.some((f) => f.message.startsWith('measure field'))).toBe(true);
+    expect(field.some((f) => f.message.includes('object "duly_duty"'))).toBe(true);
+    for (const f of converted) {
+      expect(f.hint, f.rule).not.toContain('\n');
+      expect(f.hint.length, `${f.rule}: ${f.hint}`).toBeLessThanOrEqual(200);
+      // The object's field list is the verdict's "Did you mean", not the fix line's.
+      expect(f.hint, f.rule).not.toContain('Fields on');
+    }
+  });
+
+  it('each reads as one remedy', () => {
+    const [include] = validateDatasetReferences(stackWith({ include: ['dutee'], dimensions: [], measures: [] }));
+    expect(include.hint).toBe(
+      'Name a relationship field on the join chain from "duly_task" (up to 3 hops), or drop the entry',
+    );
+    const [dimension] = validateDatasetReferences(
+      stackWith({ dimensions: [{ name: 'period', field: 'period_kee' }], measures: [] }),
+    );
+    expect(dimension.hint).toBe(
+      'Bind the dimension to a field on "duly_task", or to a `relationship[.relationship].field` path ' +
+        'whose prefix is declared in `include`.',
+    );
+  });
+
+  it('`os explain` carries what the two `fix:` lines no longer say', () => {
+    const facts: Record<string, readonly string[]> = {
+      [DATASET_INCLUDE_UNKNOWN]: [
+        'up to three hops (ADR-0071)',
+        'a lookup, master_detail, user or tree field',
+        'Declaring `a.b` implicitly includes `a`',
+        'never an ON clause',
+        '"Did you mean"',
+      ],
+      [DATASET_FIELD_UNKNOWN]: ['the hop that failed', '"Did you mean"'],
+    };
+    for (const [rule, list] of Object.entries(facts)) {
+      const text = explainRule(rule)!.paragraphs.join('\n');
+      for (const fact of list) expect(text, `${rule} explanation names ${fact}`).toContain(fact);
+    }
+  });
+});