| 1 | --- |
| 2 | description: Conditional quality-gate stage for chart coordinate verification. |
| 3 | --- |
| 4 | |
| 5 | # Verify Charts Stage |
| 6 | |
| 7 | > Conditional Generate-PPTX quality stage. Run after a deck containing data charts has finished SVG generation, before post-processing & export. Catches the 10–50 px coordinate errors AI models routinely introduce when mapping data to pixel positions. |
| 8 | |
| 9 | In Default Generate this stage is **context-independent**: it reads |
| 10 | `design_spec.md` and the generated SVGs, then runs the calculator script. The |
| 11 | lockless Quick branch is deliberately context-dependent: run it in the same |
| 12 | active session from the page decisions just authored. If that context is lost, |
| 13 | restart Quick rather than inventing a page plan from finished files. |
| 14 | |
| 15 | ## When to Run |
| 16 | |
| 17 | - The deck contains one or more data visualization charts where source values determine SVG geometry: bar lengths/heights, point positions, arc angles, polygon vertices, connector endpoints, bubble centers/radii, or flow widths/paths. |
| 18 | - SVGs are generated to `<project_path>/svg_output/`. Default enters from its declared quality-gate order; Quick runs this stage before its one lockless final checker. |
| 19 | - Post-processing (`finalize_svg.py`, `svg_to_pptx.py`) has **not yet** run. |
| 20 | |
| 21 | The calculator has direct CLI models for simple bars, lines/scatter, pie/donut, radar, and grid layouts. Composite/derived charts are **not automatically out of scope**: if their geometry reduces to repeated direct calculations, include them as `decomposable-calc`; if the calculator has no layout model but the SVG geometry is still data-driven, include them as `manual-verify` so they are not silently skipped. |
| 22 | |
| 23 | --- |
| 24 | |
| 25 | ## Step 1: Build the page list from the active profile authority |
| 26 | |
| 27 | | Active profile | Page-list authority | |
| 28 | |---|---| |
| 29 | | Default Generate | `design_spec.md §IX` plus the legacy §VII fallback below | |
| 30 | | Quick Generate | The still-active page decisions that produced the SVGs, cross-checked against every `chart-plot-area` marker; no Design Spec, lock, or substitute planning artifact is created | |
| 31 | |
| 32 | For Default, read `<project_path>/design_spec.md` §IX Content Outline as the |
| 33 | authoritative page roster and include every page whose `Visualization` |
| 34 | explicitly declares SVG geometry driven by data values. Cross-check §VII when |
| 35 | present to resolve a selected catalog key; absence from §VII means only that no |
| 36 | reusable reference was selected. For legacy specs, a real §VII data-chart row |
| 37 | may enumerate the page when its §IX block predates the explicit data-driven |
| 38 | declaration. |
| 39 | |
| 40 | For Quick, enumerate every page the current agent just authored with |
| 41 | value-driven geometry, then search `svg_output/` once for `chart-plot-area` and |
| 42 | compare the marker pages one-for-one with that active list. Add a missing marker |
| 43 | before continuing; investigate an unexpected marker instead of silently adding |
| 44 | or dropping a page. Keep the list in active context only. |
| 45 | |
| 46 | Classify each included page into exactly one mode: |
| 47 | |
| 48 | Incidental microvisuals not promoted under the active profile authority are not |
| 49 | inferred into this list. Default repairs that page's §IX `Visualization` first; |
| 50 | Quick makes the promotion decision immediately in active context and updates |
| 51 | the SVG marker before verification. |
| 52 | |
| 53 | | Mode | `charts_index.json` keys | Notes | |
| 54 | |------|--------------------------|-------| |
| 55 | | `direct-calc` | `column_chart`, `horizontal_bar_chart` | Use `calc bar`; add `--horizontal` for horizontal bars. | |
| 56 | | `direct-calc` | `line_chart`, `area_chart`, `scatter_chart` | Use `calc line`; area uses line output as the top boundary, then closes to `y_max`. | |
| 57 | | `direct-calc` | `pie_chart`, `donut_chart` | Use `calc pie`; donut passes `--inner-radius`. | |
| 58 | | `direct-calc` | `radar_chart` | Use `calc radar`; separate subcommand, not under `calc pie`. | |
| 59 | | `decomposable-calc` | `stacked_bar_chart`, `stacked_area_chart`, `grouped_bar_chart`, `dumbbell_chart`, `pareto_chart`, `dual_axis_line_chart`, `bullet_chart`, `butterfly_chart`, `waterfall_chart`, `box_plot_chart`, `gantt_chart` | Verify by repeated direct calculations; see recipes below. | |
| 60 | | `partial-calc` | `bubble_chart` | Use `calc line` for `cx/cy`; verify radius only when a size scale is explicit. | |
| 61 | | `formula-verify` | `progress_bar_chart`, `gauge_chart`, `funnel_chart` | One-line math; record the formula and resulting length/angle/width in the receipt, no calculator call needed. | |
| 62 | | `manual-verify` | `sankey_chart`, `heatmap_chart`, `treemap_chart` | Data-driven geometry exists, but the current calculator has no complete layout model. Inspect and report; do not silently skip. | |
| 63 | |
| 64 | **Out of scope** (do not include in the receipt unless the page uses a data-driven sub-chart inside the layout): |
| 65 | |
| 66 | - Pure text/number dashboards: `kpi_cards`. |
| 67 | - Tables: `comparison_table`, `basic_table`, `consulting_table`, `project_schedule_table`, `financial_statement_table`, `feature_matrix_table`, `harvey_balls_table`. |
| 68 | - Information graphics / frameworks / diagrams whose positions are layout-driven rather than value-driven: e.g. `hub_spoke`, `hub_inward_arrows`, `quadrant_text_bullets`, `quadrant_bubble_scatter` (BCG-style four-quadrant text grid — the visual bubbles are decoration, not value-mapped points), `matrix_2x2` (fixed quadrant cells with text cards), `mind_map`, `process_flow`, `numbered_steps`, `timeline`, `roadmap_vertical`, `layered_architecture`, `module_composition`, `pipeline_with_stages`, `client_server_flow`, `top_down_tree`, `journey_map`, `agenda_list`. If a deck genuinely uses these as data-driven scatter (rare — values mapped to actual `cx/cy`), promote to `partial-calc` and explain in the receipt. |
| 69 | |
| 70 | Resulting list: |
| 71 | |
| 72 | ``` |
| 73 | P03 03_market_share.svg type=bar mode=direct-calc |
| 74 | P07 07_growth.svg type=line mode=direct-calc |
| 75 | P11 11_share_split.svg type=pie mode=direct-calc |
| 76 | P15 15_pareto.svg type=pareto mode=decomposable-calc |
| 77 | ``` |
| 78 | |
| 79 | In Default, if §VII is absent, continue from §IX; this is the normal state when |
| 80 | all chart pages use custom structures. Do not guess from SVG content when §IX |
| 81 | declares no data-driven page. In Quick, do not treat marker search as a |
| 82 | replacement for the still-active authoring decisions; use it as the required |
| 83 | cross-check. |
| 84 | |
| 85 | If the filtered list is empty, output `verify-charts: active profile declares no data-driven chart geometry, nothing to verify` and stop. |
| 86 | |
| 87 | --- |
| 88 | |
| 89 | ## Step 2: Per page — read SVG, run calculator, compare, update |
| 90 | |
| 91 | For each page in the Step 1 list: |
| 92 | |
| 93 | 1. Read `<project_path>/svg_output/<page>.svg`. |
| 94 | 2. Locate the plot-area definition: |
| 95 | - Preferred: `<!-- chart-plot-area: ... -->` marker placed by Executor (see [executor-chart.md §2.1](../../references/executor-chart.md)). Read coordinates directly. |
| 96 | - If missing: derive the plot area from the SVG's axis lines (rectangular charts) or center/radius elements (radial charts). Then **add the marker back to the SVG** so future runs are not paying this cost again. |
| 97 | 3. Read the data series from the SVG's `<text>` label/value elements. |
| 98 | 4. **Read axis tick labels for every axis-based chart.** Locate the `<text>` elements along the value axis — X-axis labels for horizontal bars, Y-axis labels for vertical bars, and Y-axis labels for line-like charts. Extract the first and last tick values to determine the axis range (e.g. `0%` to `120%` → range `0,120`). Pass this range as `--value-range`, `--y-range`, or `--x-range` as appropriate. Use the attached `--*-range=min,max` form, which also keeps a negative minimum from being parsed as another option. Radar uses `--max-value` instead of a range: read the outermost ring's tick value and pass it as `--max-value`. If the SVG has no explicit tick labels (data labels only, no grid), omit the range and let the calculator auto-normalize — but flag the receipt as `scale=auto (no ticks)`. |
| 99 | |
| 100 | **Local vs absolute coordinates.** Many chart templates wrap chart content in `<g transform="translate(cx, cy)">` or similar, so child `<circle>`/`<polygon>`/`<rect>` coords are relative to that origin (e.g. radar polygon at `0,-198`, donut paths starting from `0,0` inside a translated `<g>`, dumbbell circles at `cy="0"` inside a per-row translated `<g>`). The calculator outputs **absolute** SVG coordinates. Before comparing, either add the wrapping translate's offset to the SVG coords or subtract it from the calculator's output — pick one direction and apply it consistently. |
| 101 | 5. Run the matching calculator command: |
| 102 | |
| 103 | ```bash |
| 104 | # column_chart / horizontal_bar_chart (add --horizontal for the latter) |
| 105 | # IMPORTANT: always pass --value-range from axis tick labels (step 4) |
| 106 | python3 skills/ppt-master/scripts/svg_position_calculator.py calc bar \ |
| 107 | --data "Label1:Value1,Label2:Value2" --area "x_min,y_min,x_max,y_max" \ |
| 108 | --bar-width 120 --value-range=0,axis_max |
| 109 | |
| 110 | # line_chart / area_chart / scatter_chart — area uses line output as the top boundary, then closes to y_max |
| 111 | python3 skills/ppt-master/scripts/svg_position_calculator.py calc line \ |
| 112 | --data "x1:y1,x2:y2,..." --area "x_min,y_min,x_max,y_max" --y-range=0,max |
| 113 | |
| 114 | # pie_chart — default start angle is -90 (12 o'clock); pass --start-angle only if the SVG starts elsewhere |
| 115 | python3 skills/ppt-master/scripts/svg_position_calculator.py calc pie \ |
| 116 | --data "Slice1:Value1,Slice2:Value2" --center "cx,cy" --radius 200 --start-angle -90 |
| 117 | |
| 118 | # donut_chart (pie with inner-radius) |
| 119 | python3 skills/ppt-master/scripts/svg_position_calculator.py calc pie \ |
| 120 | --data "Slice1:Value1,Slice2:Value2" --center "cx,cy" --radius 200 --inner-radius 120 --start-angle -90 |
| 121 | |
| 122 | # radar_chart (separate subcommand) — pass --max-value from the outermost ring tick |
| 123 | python3 skills/ppt-master/scripts/svg_position_calculator.py calc radar \ |
| 124 | --data "Dim1:Value1,Dim2:Value2,Dim3:Value3" --center "cx,cy" --radius 200 --max-value 100 |
| 125 | ``` |
| 126 | |
| 127 | Area chart fill path closes to the bottom edge of the plot area: |
| 128 | |
| 129 | ```svg |
| 130 | M first_x,first_y ... L last_x,last_y L last_x,y_max L first_x,y_max Z |
| 131 | ``` |
| 132 | |
| 133 | 6. **Scale-aware comparison.** Compare calculator output against the SVG's existing coordinates. Before declaring a mismatch, verify that every calculator invocation used the same axis range, plot area, center/radius, start angle, or size scale that the SVG visually declares. For `calc bar`, the output header must show `Value scale: axis ticks (...)` when the SVG has explicit ticks; if it shows `auto (max*1.1)`, go back to step 4 and re-run with the correct `--value-range`. **Do NOT update the SVG with mismatched-scale output.** Only update SVG attributes when the scale is confirmed to match and coordinates genuinely differ. Update by hand (do NOT use regex / bulk replacement — coordinates are positional and easy to swap incorrectly). |
| 134 | |
| 135 | After updating any page, follow the active profile's checker order. Default |
| 136 | reruns its quality checker to confirm nothing broke: |
| 137 | |
| 138 | ```bash |
| 139 | python3 skills/ppt-master/scripts/svg_quality_checker.py <project_path> |
| 140 | ``` |
| 141 | |
| 142 | Quick completes every chart comparison/repair first, then returns to |
| 143 | `quick-generate.md` §4 and runs its one lockless final checker. Do not insert a |
| 144 | checker call between Quick chart pages. |
| 145 | |
| 146 | --- |
| 147 | |
| 148 | ## Stacked recipe |
| 149 | |
| 150 | `stacked_bar_chart` and `stacked_area_chart` are not single-call but reduce cleanly to repeated calls on existing primitives. The operator already had to compute cumulative values to draw the SVG — verify-charts reuses them. |
| 151 | |
| 152 | **Stacked bar** — for N stacked series on the same x categories, run `calc bar` N times. Pass each segment's **height** as the data value, and shift `--area`'s `y_max` down by the sum of all lower segments for that category. Compare each segment's `(x, y, width, height)` against the SVG. |
| 153 | |
| 154 | ```bash |
| 155 | # Example: two-series stack at category "Q1" with bottom=30, top=20, plot area y from 100 to 500 |
| 156 | # Run 1 — bottom segment (origin = baseline) |
| 157 | python3 skills/ppt-master/scripts/svg_position_calculator.py calc bar \ |
| 158 | --data "Q1:30,Q2:..." --area "x_min,100,x_max,500" \ |
| 159 | --bar-width 80 --value-range=0,axis_max |
| 160 | # Run 2 — top segment (origin shifted up by bottom segment's height in pixels) |
| 161 | python3 skills/ppt-master/scripts/svg_position_calculator.py calc bar \ |
| 162 | --data "Q1:20,Q2:..." --area "x_min,100,x_max,<500 - bottom_height_px>" \ |
| 163 | --bar-width 80 --value-range=0,axis_max |
| 164 | ``` |
| 165 | |
| 166 | **Stacked area** — for N stacked series, run `calc line` N times on **cumulative** y-values (series 1 raw; series 2 = series1+series2; …). Each call yields the top boundary of one band. Each band's SVG path closes to the **previous** band's top boundary (not to `y_max`). |
| 167 | |
| 168 | If a stack page's segment positions don't reduce to this recipe (e.g., negative segments, percent-stacked with non-100 totals), mark it `manual-verify` in the receipt and inspect by hand — do not silently pass. |
| 169 | |
| 170 | --- |
| 171 | |
| 172 | ## Decomposable recipes |
| 173 | |
| 174 | Use these recipes for `decomposable-calc` and `partial-calc` pages. Each recipe must produce a receipt line; if a page cannot be reduced cleanly, mark `manual-verify` with the reason instead of dropping it. |
| 175 | |
| 176 | **Dumbbell chart** — for before/after or two-state values across categories. The two endpoints are **points**, not bar ends — `calc bar --horizontal` always anchors at `x_min`, which only matches the right endpoint. Use `calc line` × 2 instead, treating category index as the y axis: |
| 177 | |
| 178 | 1. Number categories `0.5, 1.5, …, N-0.5` so each row's y lands on its band center; set `--y-range=0,N`. The same convention applies to vertical dumbbells with the axes swapped. |
| 179 | 2. Set `--x-range` to the shared value-axis range read from ticks. |
| 180 | 3. Run `calc line` once per endpoint series with identical `--area`, `--x-range`, `--y-range`. Each output `(SVG_X, SVG_Y)` is the matching endpoint circle's `(cx, cy)`. |
| 181 | 4. Compare both endpoint circles and the connector line (`x1=cx_left, x2=cx_right, y1=y2=cy`) against the two calculated point sets. |
| 182 | |
| 183 | ```bash |
| 184 | # Horizontal dumbbell, 3 categories, value axis 0–100, plot area (100,100)–(700,460). |
| 185 | # Encode category index as the y value: row 1 → 0.5, row 2 → 1.5, row 3 → 2.5. |
| 186 | python3 skills/ppt-master/scripts/svg_position_calculator.py calc line \ |
| 187 | --data "42:0.5,55:1.5,37:2.5" --area "100,100,700,460" \ |
| 188 | --x-range=0,100 --y-range=0,3 |
| 189 | python3 skills/ppt-master/scripts/svg_position_calculator.py calc line \ |
| 190 | --data "68:0.5,71:1.5,49:2.5" --area "100,100,700,460" \ |
| 191 | --x-range=0,100 --y-range=0,3 |
| 192 | ``` |
| 193 | |
| 194 | **Pareto chart** — split into descending bars plus cumulative line: |
| 195 | |
| 196 | 1. Run `calc bar` on the descending category values with the bar axis range from ticks. |
| 197 | 2. Precompute cumulative percentages in category order. |
| 198 | 3. Run `calc line` on `0.5:cum1,1.5:cum2,...,N-0.5:cumN` with `--x-range=0,N`, the right-side percentage axis as `--y-range` (usually `--y-range=0,100`), and the same `--area` as the bars. The `n - 0.5` offset puts each cumulative point on the matching bar's center; using `1,2,…,N` shifts the polyline left by half a bar width. |
| 199 | 4. Compare bar rects, cumulative line path, and cumulative markers separately. |
| 200 | |
| 201 | **Dual-axis line chart** — split by axis: |
| 202 | |
| 203 | 1. Read the left and right Y-axis tick ranges independently. |
| 204 | 2. Run `calc line` once per series using its own `--y-range`; use the same `--x-range` and plot area for both. |
| 205 | 3. Compare each series' polyline/path points against the matching axis scale. Never use the left-axis scale for the right-axis series or vice versa. |
| 206 | |
| 207 | **Bullet chart** — performance bands + actual bar + target marker, all anchored at the same `x_min`. The bands occupy the **same** y row (they stack visually by overlapping, not by category), so run `calc bar --horizontal` once **per band** with a single data point — multi-category calls would spread y across rows: |
| 208 | |
| 209 | 1. Read the value-axis range from the band edges (the widest band's right edge = axis max). |
| 210 | 2. For each band, run `calc bar --horizontal --data "<band_name>:<right_edge_value>" --area "<x_min>,<band_y>,<x_max>,<band_y+band_height>" --bar-width <band_height>`. Each call returns one rect at the shared `(x_min, band_y)` with the value-mapped width. Compare against the band rect. |
| 211 | 3. Run `calc bar --horizontal` with a single data point for the actual value, using the actual bar's inset area (`y` and `bar-width` shrunk so the bands are visible). Compare against the actual rect. |
| 212 | 4. The target marker is a `<line>` at `x = x_min + target/axis_max × area_width`, spanning the full band height. Compute by hand and compare. |
| 213 | |
| 214 | **Butterfly chart** — mirrored horizontal bars around a vertical center line at `cx`: |
| 215 | |
| 216 | 1. Read the value-axis range and the center-line `cx` from the SVG. |
| 217 | 2. Run `calc bar --horizontal` once per side using a plot area whose `x_min = cx` and `x_max = cx + side_width`. The right-side bars' `x` and `width` map directly. |
| 218 | 3. For the left side, reuse the same calc output and mirror: each left bar's `x = cx - width`, `width` unchanged. Compare against the left rects. |
| 219 | 4. Category `y` is shared across both sides — verify left and right rows align on the same `y + height/2`. |
| 220 | |
| 221 | **Grouped bar chart** — N series sharing the same x categories, side-by-side instead of stacked: |
| 222 | |
| 223 | 1. Read the value-axis range and the plot area. |
| 224 | 2. Compute the inner-group spacing: if there are `N` series and the visual group spans width `W` per category, each series-bar's width is `W/N` and its x offset within the group is `(i - 1) × W/N`. Read these from the SVG (the first category's bars give you both). |
| 225 | 3. Run `calc bar` once per series with the **same** `--area` and `--value-range` but with each call's `--bar-width` set to the inner width. The calc's per-category center X gives the **group** center; each series-bar's actual `x = group_center - W/2 + (i-1) × W/N`. Compare against the SVG. |
| 226 | |
| 227 | **Box plot chart** — Q1/Q3 box + median line + whiskers. All five quantities are y-values on the same axis: |
| 228 | |
| 229 | 1. Read the y-axis range and plot area. For each category, the five values are min / Q1 / median / Q3 / max. |
| 230 | 2. Run `calc bar` once treating each category's box (Q3 − Q1) as a synthetic "stacked" segment with the area's `y_max` shifted to `y_axis_top - Q1 × pixels_per_unit` (the Q1 baseline). The output's `y, height` should match the box rect. |
| 231 | 3. Median y = `y_axis_top + (axis_max - median) × pixels_per_unit`. Whisker endpoints (min, max) follow the same formula. Compare each against the SVG's `<line>` y1/y2 and `<rect>` y/height. |
| 232 | |
| 233 | **Gantt chart** — task bars where each bar's `x` and `x + width` are the start and end positions on a timeline axis: |
| 234 | |
| 235 | 1. Read the timeline tick positions (the header row's x coordinates per date unit). Pixels-per-unit = `(x_unit_n - x_unit_1) / (n - 1)`. |
| 236 | 2. Run `calc line` once over `start_index:row_y` per task — output `SVG_X` gives the bar's `x`. Run it again over `end_index:row_y` — output `SVG_X` gives `x + width`. Subtract for width. |
| 237 | 3. Compare each task rect's `(x, width)` against the calculated start and end. Row y can be read directly (categories are not value-driven). |
| 238 | |
| 239 | **Waterfall chart** — floating bars connected by running totals. Each bar's top and bottom edge correspond to two points on the same value axis (`cum_before`, `cum_after`): |
| 240 | |
| 241 | 1. Read the y-axis tick range and the plot area; compute running totals in category order (start with `cum[0] = base_value`, then `cum[i] = cum[i-1] + delta[i]` for increase, `cum[i-1] - delta[i]` for decrease, reset to delta for totals). |
| 242 | 2. Build two virtual series: `top[i] = max(cum_before, cum_after)`, `bot[i] = min(cum_before, cum_after)`. Run `calc bar` twice on these with identical `--area`, `--bar-width`, `--value-range`. The `top` run's `Y` is the bar's `y`; `height = bot.Y - top.Y` for that index. |
| 243 | 3. Compare each waterfall rect's `(x, y, width, height)` against the calculated pair. Connector lines should run from `(x + width, top_or_bot[i].Y)` to `(x_next, top_or_bot[i+1].Y)` at the matching shared cumulative value. |
| 244 | 4. Total bars (full-height start/end) use `bot = 0` and the calc reduces to the standard `calc bar` recipe. |
| 245 | |
| 246 | **Bubble chart / quadrant bubble scatter** — partial calculator support: |
| 247 | |
| 248 | 1. Use `calc line` to verify bubble centers (`cx/cy`) from the X/Y values and axis ticks. |
| 249 | 2. Verify radius only if `design_spec.md`, `spec_lock.md`, the Quick active-context decision, or SVG comments declare a size scale such as `radius = sqrt(value) * k` or explicit min/max radius mapping. |
| 250 | 3. If the size scale is missing, record `radius=manual (scale missing)` and inspect relative ordering by hand. |
| 251 | |
| 252 | **Progress bar / gauge / funnel — formula-verify** (no calc call needed): |
| 253 | |
| 254 | - Progress bar: `fill_width = value / max × track_width`. Read `value`, `max`, and `track_width` from the SVG; compute and compare against the fill rect's `width`. |
| 255 | - Gauge: `needle_angle = start_angle + value / max × sweep_angle`. Read `start_angle` and `sweep_angle` from the SVG's arc path (e.g. half-circle `start_angle=-180`, `sweep_angle=180`). Compare against the needle's `transform="rotate(α ...)"` value (the most common form), or against endpoint `(cx + L·cos α, cy + L·sin α)` when the needle is drawn as an explicit line/path. |
| 256 | - Funnel: each trapezoid's `top_width = prev.bottom_width`, `bottom_width = top_width × next_value / curr_value`. Verify by walking the segments: for segment `i`, `(top_left_x, top_right_x) → bottom_x_inset = (top_width - bottom_width) / 2`. The first segment's top width comes from the design's outer frame. |
| 257 | - Receipt should quote the formula and resulting value (e.g. `formula=value/max×track_width=0.92×700=644px`, or `formula=600×850/1000=510 bottom width`). |
| 258 | |
| 259 | **Sankey / heatmap / treemap — manual verification:** |
| 260 | |
| 261 | - Sankey: no layout model for node stacking, link routing, or flow-width normalization. Verify that link widths are proportional to flow values and that node-side totals match (in = out). |
| 262 | - Heatmap: cell positions are a fixed grid (not value-driven); the value-to-color binning is what's data-driven. Verify that the color of each cell falls in the bin matching the cell's number, and that high/low extremes use the legend's high/low colors. |
| 263 | - Treemap: rectangle areas reflect value proportions but the recursive squarify layout has no calculator equivalent. Verify each rect's `width × height ≈ total_area × value / sum(values)` for top-level cells, and that nested cells sum to their parent. |
| 264 | |
| 265 | --- |
| 266 | |
| 267 | ## Step 3: Per-page receipt |
| 268 | |
| 269 | Output one line per page from the Step 1 list. Receipt count MUST equal Step 1 |
| 270 | list length — that is the gate-closing evidence. Quick does not persist these |
| 271 | lines as a generation plan or resume record. |
| 272 | |
| 273 | ``` |
| 274 | verify-charts: 03_market_share.svg | type=bar | mode=direct-calc | scale=0-100 (from ticks) | calc=ran | svg=updated |
| 275 | verify-charts: 07_growth.svg | type=line | mode=direct-calc | scale=0-120 (from ticks) | calc=ran | svg=unchanged (already accurate) |
| 276 | verify-charts: 11_share_split.svg | type=pie | mode=direct-calc | scale=N/A | calc=ran | svg=updated | marker=added (was missing) |
| 277 | verify-charts: 14_revenue_mix.svg | type=stacked-bar | mode=decomposable-calc | scale=0-200 (from ticks) | calc=ran×3 | svg=updated (per stacked recipe) |
| 278 | verify-charts: 15_unit_economics.svg | type=stacked-area | mode=manual-verify | scale=N/A | reason=percent-stacked, recipe does not apply |
| 279 | verify-charts: 16_before_after.svg | type=dumbbell | mode=decomposable-calc | scale=0-100 (from ticks) | calc=ran×2 | svg=unchanged |
| 280 | verify-charts: 17_drivers_pareto.svg | type=pareto | mode=decomposable-calc | scale=left 0-80 / right 0-100 | calc=ran×2 | svg=updated |
| 281 | verify-charts: 18_market_bubbles.svg | type=bubble | mode=partial-calc | xy=ran | radius=manual (scale missing) | svg=unchanged |
| 282 | verify-charts: 20_quota_attainment.svg | type=bullet | mode=decomposable-calc | scale=0-120 (from ticks) | calc=ran×3 (bands+actual+target) | svg=updated |
| 283 | verify-charts: 21_inflow_outflow.svg | type=butterfly | mode=decomposable-calc | scale=0-500 (from ticks) | calc=ran×2 + mirror | svg=unchanged |
| 284 | verify-charts: 22_profit_bridge.svg | type=waterfall | mode=decomposable-calc | scale=0-500 (from ticks) | calc=ran×2 (top/bot) | svg=updated |
| 285 | verify-charts: 23_quarterly_progress.svg | type=progress | mode=formula-verify | formula=68/100×800=544px | svg=unchanged |
| 286 | verify-charts: 24_capacity_gauge.svg | type=gauge | mode=formula-verify | formula=-180+72/100×180=-50.4° | svg=updated |
| 287 | verify-charts: 25_conversion_funnel.svg | type=funnel | mode=formula-verify | formula=600×850/1000=510 (seg2 bottom width) | svg=unchanged |
| 288 | verify-charts: 26_regional_compare.svg | type=grouped-bar | mode=decomposable-calc | scale=0-500 (from ticks) | calc=ran×3 | svg=updated |
| 289 | verify-charts: 27_release_plan.svg | type=gantt | mode=decomposable-calc | scale=Week1-Week24 (24 ticks, 40px/unit) | calc=ran×2 (start/end) | svg=unchanged |
| 290 | verify-charts: 28_score_distribution.svg | type=boxplot | mode=decomposable-calc | scale=0-100 (from ticks) | calc=ran×4 (Q1/Q3/whiskers) | svg=updated |
| 291 | verify-charts: 19_flow.svg | type=sankey | mode=manual-verify | link widths consistent with values | svg=unchanged |
| 292 | ``` |
| 293 | |
| 294 | --- |
| 295 | |
| 296 | ## After verification |
| 297 | |
| 298 | Default continues with [`generate-pptx`](../generate-pptx.md) Step 7. Quick |
| 299 | returns to [`quick-generate`](../profiles/quick-generate.md) §4 for its one final |
| 300 | checker and direct export. Those authorities own the remaining serial commands, |
| 301 | gates, and success criteria. |
| 302 |