@micha.bigler/ui-core-micha 3.1.2 → 3.2.1

package/src/components/charts/chartDefaults.js

@@ -153,6 +153,29 @@ export const PACKAGE_DEFAULT_MARGIN = {
 // as clipped even when nothing is actually cut off).
 const ROTATED_TICK_CLEARANCE_PX = 8;
 
+// UCM-CHART-16: the FLAT (angle 0) tick band used to be the unconditional TICK_BAND_BASE_PX
+// regardless of the actual tick font size -- fine for MUI's own generic default, but MUI's
+// internal fit check (`shortenLabels`, against `tickLabelsMaxHeight`) blanks EVERY tick label the
+// moment the real rendered text is even slightly taller than what that flat floor leaves room
+// for once MUI's own tick/gap overhead (and, when an axis title shares the band, its own gap) is
+// subtracted. `TICK_BAND_BASE_PX` alone was a near-miss with essentially no margin at any font
+// size above whatever MUI itself implicitly assumed -- two hram consumers independently patched
+// around it with the same empirically-measured `height: 56`, and a third, titleless case broke at
+// a tick font just 1px above the untitled default.
+//
+// These three constants are DERIVED, not guessed: binary-searched against the real, unmocked
+// `BarChart` rendered in this repo's own dev harness (`dev/entries.jsx`'s `chart-probe` entry,
+// Chrome, this package's own DM Sans default -- the taller of the two fonts checked; MUI's Roboto
+// fallback needs visibly less and was never the trigger) at tick font sizes 11-18px, with and
+// without an axis title:
+//   required flat tickBand   ~= ceil(fontSize * TICK_TEXT_HEIGHT_FACTOR) + TICK_BAND_MUI_OVERHEAD_PX
+//   required tickBand+title  ~= that, plus TICK_BAND_TITLE_EXTRA_PX, plus AXIS_TITLE_BAND_PX
+// matched every measured threshold exactly or over by at most 1px, never under, across ten
+// font-size/title combinations -- see UCM-CHART-16's work order for the full measurement table.
+const TICK_TEXT_HEIGHT_FACTOR = 1.3;
+const TICK_BAND_MUI_OVERHEAD_PX = 9;
+const TICK_BAND_TITLE_EXTRA_PX = 2;
+
 // THEME-9: MUI X-Charts' own default y-axis width is a flat 45px (ticks) +
 // 20px (label, if present) = 65px regardless of what the ticks actually say
 // -- confirmed against @mui/x-charts' own DEFAULT_AXIS_SIZE_WIDTH /
@@ -291,13 +314,18 @@ export function defaultNumericTickFormatter(locale) {
     : new Intl.NumberFormat(locale).format(value));
 }
 
-// UCM-CHART-12: named size tokens, resolved through the theme's 8px spacing unit
-// (`src/theme/tokens.js`'s `spacing: 8`). `standard` is pinned to the pre-existing deployed
-// default (`TimeSeriesChart`'s old `CHART_HEIGHT = 320`) so this migration does not also
-// silently redraw every already-shipped default-sized chart; `compact`/`tall` are proportional.
-// Documented plainly in `docs/CHART-LAYOUT.md` -- these are visible product decisions, not
-// internal plumbing.
-export const CHART_SIZE_SPACING_UNITS = { compact: 30, standard: 40, tall: 50 };
+// UCM-CHART-15: named size tokens, resolved through the theme's 8px spacing unit
+// (`src/theme/tokens.js`'s `spacing: 8`). Through UCM-CHART-12/14, `standard` stayed pinned to
+// the pre-existing deployed default (`TimeSeriesChart`'s old `CHART_HEIGHT = 320`) so that
+// migration did not also silently redraw every already-shipped default-sized chart -- that pin
+// was a migration guardrail, not a design verdict. The migration it protected is complete, and
+// the operator judged the whole scale too cramped (`tall` had already forced hram to use the
+// `height` px escape to get past the old ceiling), so this WO shifts every token up one step and
+// adds two steps above the old `tall`, chosen rather than inherited. Documented plainly in
+// `docs/CHART-LAYOUT.md` -- these are visible product decisions, not internal plumbing.
+export const CHART_SIZE_SPACING_UNITS = {
+  compact: 40, standard: 50, tall: 60, extra_tall: 70, super_tall: 80,
+};
 
 // UCM-CHART-12 Rule 2: every band is its own measured content, or zero -- no band is ever a
 // constant taken on faith. These two ARE constants, but only for the "content is present" case;
@@ -384,7 +412,18 @@ function resolveXAxisGeometry(axis, xLabelsMode, defaultLineHeight, measureTextW
     angle = needsRotation ? -45 : 0;
   } // "horizontal" always stays at angle 0
 
-  if (angle === 0) return { tickBand: TICK_BAND_BASE_PX, angle: 0 };
+  if (angle === 0) {
+    // UCM-CHART-16: derive the flat band from the actual tick font size instead of the
+    // unconditional floor -- `axis?.label` is the SAME signal `resolveChartLayout` uses to decide
+    // whether an axis title also shares this band (`xTitleBand`), so a titled axis reserves the
+    // extra room its own gap costs, precisely where the near-miss was.
+    const hasTitle = Boolean(axis?.label);
+    const flatTickBand = fontSize > 0
+      ? Math.ceil(fontSize * TICK_TEXT_HEIGHT_FACTOR) + TICK_BAND_MUI_OVERHEAD_PX
+        + (hasTitle ? TICK_BAND_TITLE_EXTRA_PX : 0)
+      : TICK_BAND_BASE_PX;
+    return { tickBand: Math.max(TICK_BAND_BASE_PX, flatTickBand), angle: 0 };
+  }
   // Rotation is a visual instruction independent of whether a font size is knowable here -- an
   // "angled" axis still rotates even when `fontSize` can't be resolved (no theme fallback given),
   // it just can't project a tighter band than the floor without one.
@@ -404,11 +443,11 @@ function resolveChartHeightPx(size, height, spacing) {
   const units = CHART_SIZE_SPACING_UNITS[size];
   if (units == null) {
     throw new Error(
-      `[ui-core-micha] Unknown chart size="${size}". Use "compact" | "standard" | "tall", `
-      + 'or pass height (in px) for the documented escape.',
+      `[ui-core-micha] Unknown chart size="${size}". Use "compact" | "standard" | "tall" | `
+      + '"extra_tall" | "super_tall", or pass height (in px) for the documented escape.',
     );
   }
-  // MUI's `theme.spacing(n)` returns a CSS length STRING ("240px"), not a number -- the chart
+  // MUI's `theme.spacing(n)` returns a CSS length STRING ("320px"), not a number -- the chart
   // height feeds straight into MUI X-Charts' own numeric `height` prop, so it must be unwrapped
   // back to a px number via the same `cssLengthToPixels` the rest of this file already uses.
   return typeof spacing === 'function' ? cssLengthToPixels(spacing(units)) : units * 8;

package/tests/BarChart.test.jsx

@@ -31,10 +31,10 @@ describe('BarChart preset', () => {
       legend: { position: { vertical: 'bottom', horizontal: 'start' } },
     });
     expect(props.hideLegend).toBe(true);
-    // UCM-CHART-12: size defaults to "standard" (320px, the historical default) -- the wrapper
-    // always carries an explicit height now, width stays responsive.
-    expect(props.height).toBe(320);
-    expect(window.getComputedStyle(screen.getByTestId('bar-chart-container')).height).toBe('320px');
+    // UCM-CHART-12/UCM-CHART-15: size defaults to "standard" (400px) -- the wrapper always
+    // carries an explicit height now, width stays responsive.
+    expect(props.height).toBe(400);
+    expect(window.getComputedStyle(screen.getByTestId('bar-chart-container')).height).toBe('400px');
   });
 
   it.each([
@@ -78,11 +78,13 @@ describe('BarChart preset', () => {
   // UCM-CHART-12: `size`/`height` resolution, wired through the actual component. Replaces the
   // deleted `minHeight`/`aspect` CHART-8 trio -- see the removed-prop assertions below for the
   // migration side of this.
-  describe('size/height resolution (UCM-CHART-12)', () => {
+  describe('size/height resolution (UCM-CHART-12, UCM-CHART-15)', () => {
     it.each([
-      ['compact', 240],
-      ['standard', 320],
-      ['tall', 400],
+      ['compact', 320],
+      ['standard', 400],
+      ['tall', 480],
+      ['extra_tall', 560],
+      ['super_tall', 640],
     ])('resolves size="%s" to %ipx, on both the chart height and the wrapper', (size, px) => {
       renderChart({ series: [{ data: [1] }], size });
       expect(chartSpy.mock.calls.at(-1)[0].height).toBe(px);

package/tests/LineChart.test.jsx

@@ -36,7 +36,7 @@ describe('LineChart preset', () => {
 
   // UCM-CHART-12: `size`/`height` resolution, wired through the actual component. Replaces the
   // deleted `minHeight`/`aspect` CHART-8 trio.
-  describe('size/height resolution (UCM-CHART-12)', () => {
+  describe('size/height resolution (UCM-CHART-12, UCM-CHART-15)', () => {
     function renderLine(props) {
       return render(
         <ThemeProvider theme={createTheme()}>
@@ -48,9 +48,11 @@ describe('LineChart preset', () => {
     afterEach(cleanup);
 
     it.each([
-      ['compact', 240],
-      ['standard', 320],
-      ['tall', 400],
+      ['compact', 320],
+      ['standard', 400],
+      ['tall', 480],
+      ['extra_tall', 560],
+      ['super_tall', 640],
     ])('resolves size="%s" to %ipx, on both the chart height and the wrapper', (size, px) => {
       renderLine({ size });
       expect(chartSpy.mock.calls.at(-1)[0].height).toBe(px);

package/tests/ScatterChart.test.jsx

@@ -235,13 +235,15 @@ describe('ScatterReferenceCurve / ScatterReferenceLine (THEME-10)', () => {
 
 // UCM-CHART-12: `size`/`height` resolution, wired through the actual component. Replaces the
 // deleted `minHeight`/`aspect` CHART-8 trio.
-describe('ScatterChart size/height resolution (UCM-CHART-12)', () => {
+describe('ScatterChart size/height resolution (UCM-CHART-12, UCM-CHART-15)', () => {
   afterEach(() => { cleanup(); vi.clearAllMocks(); });
 
   it.each([
-    ['compact', 240],
-    ['standard', 320],
-    ['tall', 400],
+    ['compact', 320],
+    ['standard', 400],
+    ['tall', 480],
+    ['extra_tall', 560],
+    ['super_tall', 640],
   ])('resolves size="%s" to %ipx, on both the chart height and the wrapper', (size, px) => {
     renderScatter({ size });
     expect(scatterSpy.mock.calls.at(-1)[0].height).toBe(px);

package/tests/chartAxisTickBand.test.jsx

@@ -0,0 +1,95 @@
+// @vitest-environment jsdom
+import React from 'react';
+import {
+  afterAll, afterEach, beforeAll, describe, expect, it,
+} from 'vitest';
+import { cleanup, render } from '@testing-library/react';
+import { ThemeProvider, createTheme } from '@mui/material/styles';
+
+import { BarChart } from '../src/components/charts/BarChart';
+
+// UCM-CHART-16: MUI's own tick-label fit check (`shortenLabels`, weighed against
+// `tickLabelsMaxHeight`) depends on a REAL SVG text measurement (`getBBox`), which jsdom does not
+// implement -- `SVGElement.prototype.getBBox` is not a function here, so MUI's own
+// `getStringSize` falls back to `getBoundingClientRect`, which jsdom always reports as 0x0. Every
+// measured height therefore comes back 0, MUI's fit check trivially "fits" any text, and the real
+// defect (every tick label blanked) can never be observed by rendering the unmocked chart as-is --
+// a test that skips this setup would pass whether or not the resolver's band is correct, i.e. be
+// exactly the "mocked prop-assertion" trap this package's own tests warn against elsewhere.
+//
+// This installs a deterministic `getBBox` instead, so the SAME code MUI itself runs is actually
+// exercised: height scaled off the measurement span's own `fontSize`, at a ratio (1.28) chosen to
+// sit inside the real near-miss window this WO's own work order measured against a real browser
+// (`resolveXAxisGeometry`'s `TICK_TEXT_HEIGHT_FACTOR` comment) -- large enough that the pre-fix
+// unconditional floor already fails a titled axis at the theme's own default tick font, small
+// enough that the untitled default (never broken) still passes. Width is deliberately near-zero so
+// only the HEIGHT dimension of MUI's fit check is exercised; each chart also sets an explicit
+// `width` so MUI's real responsive sizing (ResizeObserver, unavailable in jsdom) never enters into
+// it.
+function installHeightOnlyTextMeasurement() {
+  const original = SVGElement.prototype.getBBox;
+  // eslint-disable-next-line func-names
+  SVGElement.prototype.getBBox = function getBBox() {
+    const fontSize = Number.parseFloat(this.style.fontSize) || 12;
+    return { x: 0, y: 0, width: 1, height: fontSize * 1.28 };
+  };
+  return () => {
+    SVGElement.prototype.getBBox = original;
+  };
+}
+
+describe('x-axis tick band leaves MUI room for one real line of tick text (UCM-CHART-16)', () => {
+  let restoreGetBBox;
+
+  beforeAll(() => {
+    restoreGetBBox = installHeightOnlyTextMeasurement();
+  });
+
+  afterAll(() => {
+    restoreGetBBox();
+  });
+
+  afterEach(cleanup);
+
+  // WO scope item 1's own signature: an axis title AND horizontal tick labels sharing the same
+  // band, at the theme's own default tick font -- no explicit `height`/`tickLabelStyle` overrides
+  // anywhere, so this exercises the resolver's own default reservation end to end, the exact path
+  // two hram consumers had to work around by hand.
+  it('renders non-empty tick labels when the axis has both a title and horizontal ticks', () => {
+    const { container } = render(
+      <ThemeProvider theme={createTheme()}>
+        <BarChart
+          series={[{ data: [24, 36, 28], label: 'Opened' }]}
+          xAxis={[{ data: ['A', 'B', 'C'] }]}
+          xAxisLabel="Category"
+          width={600}
+        />
+      </ThemeProvider>,
+    );
+    const tickTexts = Array.from(container.querySelectorAll('.MuiChartsAxis-bottom .MuiChartsAxis-tickLabel'))
+      .map((node) => node.textContent);
+    expect(tickTexts).toHaveLength(3);
+    expect(tickTexts.every((text) => text.length > 0)).toBe(true);
+  });
+
+  // Non-goal guardrail: the rotated path projects its own band from real measured/estimated text
+  // width and must stay exactly as before -- this WO only touches the flat (angle 0) case.
+  it('leaves the rotated tick path unaffected', () => {
+    const { container } = render(
+      <ThemeProvider theme={createTheme()}>
+        <BarChart
+          series={[{ data: [24, 36, 28, 12, 9, 7, 15] }]}
+          xAxis={[{
+            data: Array.from({ length: 7 }, (_, i) => `A rather long category label ${i}`),
+          }]}
+          xLabels="angled"
+          width={600}
+        />
+      </ThemeProvider>,
+    );
+    const tickTexts = Array.from(container.querySelectorAll('.MuiChartsAxis-bottom .MuiChartsAxis-tickLabel'))
+      .map((node) => node.textContent);
+    expect(tickTexts).toHaveLength(7);
+    expect(tickTexts.every((text) => text.length > 0)).toBe(true);
+  });
+});

package/tests/chartDefaults.test.js

@@ -115,8 +115,8 @@ describe('chart chrome defaults', () => {
     expect(timeSeriesProps.grid).toEqual({ horizontal: true });
     expect(timeSeriesProps.skipAnimation).toBe(true);
     // UCM-CHART-12: TimeSeriesChart's inner BarChart now takes size="standard" instead of a
-    // fixed height prop -- the resolved height must still land on the historical 320px default.
-    expect(timeSeriesProps.height).toBe(320);
+    // fixed height prop. UCM-CHART-15 shifted "standard" from 320px to 400px.
+    expect(timeSeriesProps.height).toBe(400);
   });
 
   it('keeps caller tick font, grid, showMark, and legendPosition values instead of the defaults', () => {
@@ -551,15 +551,22 @@ describe('resolveChartLayout composition invariant (UCM-CHART-12)', () => {
   });
 });
 
-describe('resolveChartLayout size tokens and height escape (UCM-CHART-12)', () => {
+describe('resolveChartLayout size tokens and height escape (UCM-CHART-12, UCM-CHART-15)', () => {
   it.each(Object.entries(CHART_SIZE_SPACING_UNITS))('resolves size="%s" through the theme spacing scale', (size, units) => {
     const layout = resolveChartLayout({ size, spacing: theme.spacing });
     expect(layout.chartHeight).toBe(units * 8);
   });
 
-  it('pins "standard" to the historical 320px default', () => {
-    const layout = resolveChartLayout({ size: 'standard', spacing: theme.spacing });
-    expect(layout.chartHeight).toBe(320);
+  // UCM-CHART-15: hardcoded independently of CHART_SIZE_SPACING_UNITS -- the test above computes
+  // its expectation from the same source under test and would pass unchanged against either the
+  // old or the new scale. This one is written to fail against the pre-CHART-15 values (240/320/400).
+  it('resolves the five size tokens to their documented pixel heights', () => {
+    const px = Object.fromEntries(['compact', 'standard', 'tall', 'extra_tall', 'super_tall'].map(
+      (size) => [size, resolveChartLayout({ size, spacing: theme.spacing }).chartHeight],
+    ));
+    expect(px).toEqual({
+      compact: 320, standard: 400, tall: 480, extra_tall: 560, super_tall: 640,
+    });
   });
 
   it('lets height override the size token entirely', () => {
@@ -567,13 +574,63 @@ describe('resolveChartLayout size tokens and height escape (UCM-CHART-12)', () =
     expect(layout.chartHeight).toBe(111);
   });
 
-  it('throws on an unknown size token', () => {
+  // UCM-CHART-15: the height escape still wins for a token added in this WO, not only a
+  // pre-existing one.
+  it('lets height override a token that has no call site yet', () => {
+    const layout = resolveChartLayout({ size: 'super_tall', height: 111, spacing: theme.spacing });
+    expect(layout.chartHeight).toBe(111);
+  });
+
+  it('throws on an unknown size token, naming all five valid tokens', () => {
     expect(() => resolveChartLayout({ size: 'huge', spacing: theme.spacing })).toThrow(/Unknown chart size/);
+    expect(() => resolveChartLayout({ size: 'huge', spacing: theme.spacing })).toThrow(
+      /"compact" \| "standard" \| "tall" \| "extra_tall" \| "super_tall"/,
+    );
   });
 
   it('falls back to a numeric 8px unit when no spacing function is given', () => {
     const layout = resolveChartLayout({ size: 'standard' });
-    expect(layout.chartHeight).toBe(320);
+    expect(layout.chartHeight).toBe(400);
+  });
+});
+
+describe('resolveChartLayout flat x-axis tick band leaves MUI room to render (UCM-CHART-16)', () => {
+  // Third occurrence (WO Part A): no title, just a tick font 1px above the untitled default --
+  // already enough to blank every label under the pre-fix, unconditional TICK_BAND_BASE_PX=25.
+  // 26 is not invented: binary-searched against the real, unmocked `BarChart` rendered in this
+  // repo's own dev harness (Chrome, this package's own DM Sans default) -- 25 still blanked every
+  // tick, 26 was the smallest axis height that didn't. A test computing its own expectation from
+  // `CHART_TICK_TEXT_HEIGHT_FACTOR`-style constants would pass whatever those constants say,
+  // proving nothing; this number came from outside the code under test.
+  it('reserves enough room for a tick font one pixel above the untitled default (measured threshold: 26px)', () => {
+    const layout = resolveChartLayout({
+      xAxis: [{
+        scaleType: 'band',
+        data: ['Urban', 'Peri-urban', 'Rural', 'Access', 'Village'],
+        tickLabelStyle: { fontSize: 13 },
+      }],
+      yAxis: [{ scaleType: 'linear' }],
+      xLabels: 'horizontal',
+      spacing: theme.spacing,
+    });
+    expect(layout.xAxis[0].height).toBeGreaterThanOrEqual(26);
+  });
+
+  // Rule 2 (WO non-goal guardrail): an axis without a title still reserves only the tick band --
+  // this WO's extra title-driven margin must not leak in when there is no title to share it with.
+  // Reviewer finding: asserting `xTitleBand === 0` alone passes whether or not the +2px title
+  // margin leaked into `xAxisBand` instead -- the band/height values themselves have to be
+  // checked against the same tick font's no-title formula (`ceil(fontSize * 1.3) + 9`).
+  it('does not add the title margin when the axis has no label', () => {
+    const layout = resolveChartLayout({
+      xAxis: [{ scaleType: 'band', data: ['A', 'B'], tickLabelStyle: { fontSize: 13 } }],
+      yAxis: [{ scaleType: 'linear' }],
+      xLabels: 'horizontal',
+      spacing: theme.spacing,
+    });
+    expect(layout.bands.xTitleBand).toBe(0);
+    expect(layout.bands.xAxisBand).toBe(26);
+    expect(layout.xAxis[0].height).toBe(26);
   });
 });
 

package/work-orders/UCM-CHART-15.md

@@ -0,0 +1,187 @@
+# UCM-CHART-15 — Shift the chart size scale up one step, and raise the ceiling
+
+## Part A — Envelope
+
+*Authored by the Expertenchat. Authoritative WHAT/WHY.*
+
+### Goal
+
+The named chart sizes become one step taller, and the scale gains two steps above `tall`.
+
+| token | today | new |
+|---|---|---|
+| `compact` | 30 → 240 px | **40 → 320 px** |
+| `standard` | 40 → 320 px | **50 → 400 px** |
+| `tall` | 50 → 400 px | **60 → 480 px** |
+| `extra_tall` | — | **70 → 560 px** |
+| `super_tall` | — | **80 → 640 px** |
+
+The 10-unit step is preserved throughout, and every value stays a clean multiple of the theme's 8 px
+spacing unit.
+
+### Why
+
+Two independent pressures, both from real call sites rather than speculation.
+
+**The ceiling is too low.** `tall` (400 px) is the largest token, and hram has already had to use the
+documented `height` escape to get past it — `StructuralReachabilityPanel` sits at `height={480}` with
+a comment recording exactly this: *"no size token goes taller than `tall`"*. An escape used because
+the scale ends is a scale that ends too early.
+
+**The whole scale is too cramped.** The operator's judgement, on existing plots and not only the new
+ones. That judgement lands on a value that was never chosen on its merits: the comment at
+`src/components/charts/chartDefaults.js:295` says `standard` is
+
+> "pinned to the pre-existing deployed default (`TimeSeriesChart`'s old `CHART_HEIGHT = 320`) so this
+> migration does not also silently redraw every already-shipped default-sized chart"
+
+That was a **migration guardrail, not a design verdict** — 320 was kept because it was the previous
+value. The migration it protected is complete, so the pin has served its purpose and what remains is
+a height inherited rather than decided.
+
+### The blast radius is one app, and that is why now
+
+Measured across the workspace on 2026-08-24:
+
+```
+hram                    3.0.1     <- the only 3.x consumer
+14 other apps           2.41.3 / 2.37.0
+```
+
+The size tokens are a **3.0.0 feature** (this repo's own CHANGELOG marks 3.0.0 "Breaking": `size`
+replaced `minHeight`/`height`/`aspect`). On 2.x the scale does not exist. So no chart outside hram
+changes, and the verification surface is one application.
+
+**That inverts the usual caution into urgency:** fourteen apps are still to migrate onto 3.x. Every
+app that migrates onto a scale already known to be too cramped has to be revisited afterwards.
+Correcting the scale before they migrate is strictly cheaper than after.
+
+### Version: minor, by operator decision — and what that obliges
+
+Redefining what an existing public token renders is breaking under semver, and the Expertenchat
+recommended a major. **The operator decided minor on 2026-08-24; that decision stands and this WO
+implements it.**
+
+The consequence has to be carried somewhere, so it is carried here: a minor version can arrive
+through automation. Renovate's weekly run bumps minors without a human reading the diff, and on this
+estate that triage is also the vehicle that opens `develop → main`. A silent minor could therefore
+make every hram chart 80 px taller in a PR nobody read as a visual change.
+
+Two obligations follow, and they are not optional decoration:
+
+1. **The CHANGELOG entry must lead with the redraw**, in the plainest possible words: every existing
+   `compact`/`standard`/`tall` chart becomes 80 px taller. Not a bullet at the bottom — the first
+   line of the entry.
+2. **Release and consumption are coordinated**, not left to the weekly bump. `hram`'s pin bump and
+   its own verification are `HRAM-CHT-5` and land deliberately.
+
+### Scope
+
+**`src/components/charts/chartDefaults.js`**
+
+1. `CHART_SIZE_SPACING_UNITS` becomes `{ compact: 40, standard: 50, tall: 60, extra_tall: 70,
+   super_tall: 80 }`.
+2. **Rewrite the pin comment at `:294-299`, do not delete it.** It explains why 320 was there; without
+   a successor the next reader sees an unexplained shift. The new text should say what the old pin
+   was for, that its migration is complete, and that the scale is now chosen rather than inherited.
+
+**The enumeration sites — all of them.** The valid-size list is written out in more places than the
+one that matters, and a half-updated enumeration is this change's most likely defect:
+
+3. `resolveChartHeightPx`'s error message (`:407`) — `"compact" | "standard" | "tall"`.
+4. `assertRemovedChartProp`'s guidance string in **each** chart component that carries it
+   (`LineChart.jsx:72`, `BarChart.jsx:54`, and the same call in `ScatterChart`).
+5. The `size` JSDoc in **each** preset (`LineChart.jsx:44`, `BarChart.jsx:27`, `ScatterChart.jsx:155`).
+6. `docs/CHART-LAYOUT.md`.
+7. The CHANGELOG entry described above.
+
+Grep for the literal `"tall"` before declaring this done; the list above is what was found on
+2026-08-24 and is not guaranteed complete.
+
+### Non-goals / do not touch
+
+- `resolveChartLayout`'s geometry, the axis-band resolution, margins, `xLabels`, rotation logic.
+- The `height` px escape — it stays exactly as documented.
+- `ChartFrame`'s `minHeight` semantics.
+- Any consuming app. hram's adoption is `HRAM-CHT-5`.
+- Adding a sixth step. If 640 px proves too small later, the scale extends by another 10 units; do
+  not pre-add one now.
+
+### Risks
+
+- **A half-updated enumeration.** Adding the tokens to the resolver but not to the error message
+  produces a runtime error that lists only three valid values while five work — which reads as a bug
+  in the caller's code, not in this package.
+- **A test that asserts the token names but not their values** would pass against both the old and
+  new scale and prove nothing. See test 1.
+- The two new tokens have **no call site yet** in this repo. That is intended — `HRAM-CHT-5` adopts
+  them — but it means nothing here exercises them beyond the resolver test.
+
+### Tests to write
+
+1. `resolveChartHeightPx` returns **320 / 400 / 480 / 560 / 640** for the five tokens — asserting the
+   pixel values, not just that a number comes back. Written so it fails against the current scale.
+2. An unknown size still throws, and the message names **all five** valid tokens.
+3. The `height` escape still wins over `size`, for a new token as well as an old one.
+4. Existing chart-layout tests that hard-code 240/320/400 are updated deliberately, each one seen
+   and changed rather than mass-replaced — one of them may be asserting the old value *on purpose*.
+
+---
+
+## Part B — Implementation map
+
+`.claude/models.local.json` has no local override, so the default applies: `implementation.runtime`
+is `claude`/`sonnet` — the Orchestrator implemented directly, no Codex dispatch, no preamble/progress
+contract needed.
+
+Context package used:
+
+- `src/components/charts/chartDefaults.js:294-300` (the pin comment + `CHART_SIZE_SPACING_UNITS`)
+  and `:402-419` (`resolveChartHeightPx`, its error message, and the `theme.spacing` unwrap comment).
+- Enumeration sites confirmed by grep for the literal `"tall"` (matched the WO's own 2026-08-24
+  list exactly, nothing extra found): `LineChart.jsx:44,72`, `BarChart.jsx:27,54`,
+  `ScatterChart.jsx:155,198`, `docs/CHART-LAYOUT.md:66,73-75`.
+- Existing hardcoded-value tests located via grep for `240|320|400` across `tests/*.test.{js,jsx}`:
+  `chartDefaults.test.js:119,562,576`, `BarChart.test.jsx:36,83-85`, `LineChart.test.jsx:51-53`,
+  `ScatterChart.test.jsx:242-244`. Distinguished from unrelated same-valued `minHeight`/`ChartFrame`
+  test fixtures (`chartDefaults.test.js:291,298,308,315,318`, `ChartFrame.test.jsx:294,311`,
+  `chart-api-census.test.js:196`), which were left untouched — they assert an arbitrary prop value,
+  not a size-token pixel height.
+
+---
+
+## Part C — Orchestrator only
+
+> **STOP — everything below addresses the Orchestrator.**
+
+**Tier 3 · tests: the four resolver cases plus the updated layout tests**
+
+Shared-core — a change *inside* `ui-core-micha` is Tier 3 by the tiering table regardless of diff
+size, and this one redefines rendered output for every consumer that reaches 3.x.
+
+- `reviewer` — the enumeration completeness and the test's ability to fail are its brief.
+- `ui_reviewer` — the scale as a design decision: does the 10-unit step still read as a coherent
+  scale with five members, and is `super_tall` distinguishable from `extra_tall` in practice.
+- `sec_reviewer` — not run. No auth, no data, no exposure surface.
+- Concurrent, full context.
+
+### Release
+
+Minor bump per the operator's decision → **3.2.0** from the current 3.1.1. Follow this repo's release
+procedure. The CHANGELOG obligation in Part A is a release gate, not a nicety: if the entry does not
+lead with "every existing chart becomes 80 px taller", the release is not ready.
+
+Do **not** bump hram from here. `HRAM-CHT-5` owns that, and it carries the visual verification.
+
+### Register
+
+Row `UCM-CHART-15`, review notes in the required shape, the published version, landing SHA(s) in a
+second commit before the push. Record explicitly that a **major was recommended and minor was chosen
+by the operator** — a future reader tracing a silent redraw should find that decision, not infer it.
+
+### Log
+
+- **2026-08-24** — Envelope authored. Operator judged all three existing tokens too cramped and chose
+  a full one-step shift over adding a token at the top, accepting the breaking redraw; added
+  `super_tall` to the two steps proposed. Version set to minor against the Expertenchat's
+  recommendation of major, recorded above with its consequence.