Add visual analysis charts

README.md

@@ -16,6 +16,52 @@ This repository documents a local Mac fine-tuning run for `LiquidAI/LFM2.5-8B-A1
 
 It contains compact, reproducible artifacts only: configs, manifests, eval JSON, logs, and the focused tool-call repair dataset. Large model checkpoints are released separately under `sjakek/LFM-2.5-8B-1B-hermes-ft`.
 
+## Visual Overview
+
+These figures summarize the main mechanism and results. They are generated from the JSON reports in this repository with `scripts/build_visual_assets.py`, so the visuals are reproducible rather than hand-drawn.
+
+### End-to-end training and export flow
+
+![Pipeline overview](visuals/pipeline_overview.svg)
+
+The project starts from the BF16 LFM2.5 MoE checkpoint, constructs an int8-expert/BF16-router mixed core, runs grouped MoE expert/router updates for three epochs, uses eval failures to build focused LoRA repair datasets, then validates both MLX and llama.cpp exports.
+
+### Why the mixed-quant runtime matters
+
+![Memory model](visuals/memory_model.svg)
+
+The core memory move is storing MoE experts as int8 while keeping routers and non-expert layers in BF16. This makes the checkpoint small enough to work with locally, but the chart also shows why a naive simultaneous gradient over all experts would still be expensive. The implemented route is grouped semi-full-gradient training: update multiple MoE layers together, then requantize before moving to the next group.
+
+### Selecting the grouped training size
+
+![Group sweep memory and time](visuals/group_sweep_memory_time.svg)
+
+The 10K-token group sweep showed the practical Mac tradeoff. Larger groups improved elapsed time, but group size 11 approached the 60 GB hard stop. The selected run used overlapping groups of four layers with stride three for stability, while the sweep demonstrated that larger grouped updates were mechanically possible on this 64 GB machine.
+
+### Dataset filtering at the 10K cap
+
+![Dataset filtering at 10K](visuals/dataset_filtering_10k.svg)
+
+The token cap is per example. The 10K artifact retained 582 train examples, 29 validation examples, and 26 test examples from the filtered Hermes trace pool after dropping longer rows from the earlier 16K artifact.
+
+### Reliability across repair stages
+
+![Eval progression](visuals/eval_progression.svg)
+
+The broad colloquial router attempts preserved structured tool-call parsing but failed to fix terminal/file routing. The successful iter10 repair used structured chat rows with `assistant.tool_calls`, prompt masking, and the exact fixed Hermes tool schema.
+
+### Final fixed-Hermes coverage
+
+![Fixed Hermes category eval](visuals/fixed_hermes_category_eval.svg)
+
+The accepted fused MLX checkpoint passed the parser-disabled fixed-Hermes suite across browser, terminal, file, no-tool, and tool-result finalization categories with zero text-tool leaks.
+
+### GGUF quant export result
+
+![GGUF quant size and quality](visuals/gguf_quant_size_quality.svg)
+
+The GGUF path exports from a dequantized BF16/HF source, then produces stock llama.cpp XL-approximation quants using tensor-type policies and the Hermes/tool-router imatrix. All four released quants passed the same 43-case fixed-Hermes eval at 64K context.
+
 ## What Was Trained
 
 The run had two stages.

scripts/build_visual_assets.py

@@ -0,0 +1,383 @@
+#!/usr/bin/env python3
+"""Build small SVG visualizations for the Hugging Face analysis repo.
+
+The renderer intentionally avoids third-party plotting dependencies so the
+figures can be regenerated on a fresh Mac with only the standard library.
+"""
+
+from __future__ import annotations
+
+import html
+import json
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+OUT = ROOT / "visuals"
+
+BG = "#ffffff"
+INK = "#1f2937"
+MUTED = "#6b7280"
+GRID = "#e5e7eb"
+BLUE = "#2563eb"
+TEAL = "#0891b2"
+GREEN = "#059669"
+ORANGE = "#d97706"
+RED = "#dc2626"
+PURPLE = "#7c3aed"
+SLATE = "#475569"
+
+
+def esc(value: object) -> str:
+    return html.escape(str(value), quote=True)
+
+
+def write_svg(path: Path, width: int, height: int, body: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        f"""<svg xmlns="http://www.w3.org/2000/svg" width="{width}" height="{height}" viewBox="0 0 {width} {height}" role="img">
+  <rect width="100%" height="100%" fill="{BG}"/>
+  <style>
+    .title {{ font: 700 22px -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; fill: {INK}; }}
+    .subtitle {{ font: 400 13px -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; fill: {MUTED}; }}
+    .label {{ font: 600 12px -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; fill: {INK}; }}
+    .small {{ font: 400 11px -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; fill: {MUTED}; }}
+    .axis {{ stroke: {GRID}; stroke-width: 1; }}
+    .tick {{ font: 400 10px -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; fill: {MUTED}; }}
+    .value {{ font: 700 11px -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; fill: {INK}; }}
+    .node-title {{ font: 700 13px -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; fill: {INK}; }}
+    .node-text {{ font: 400 11px -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; fill: {MUTED}; }}
+  </style>
+  {body}
+</svg>
+""",
+        encoding="utf-8",
+    )
+
+
+def load_json(rel: str) -> dict:
+    return json.loads((ROOT / rel).read_text(encoding="utf-8"))
+
+
+def header(title: str, subtitle: str) -> str:
+    return (
+        f'<text x="32" y="38" class="title">{esc(title)}</text>'
+        f'<text x="32" y="60" class="subtitle">{esc(subtitle)}</text>'
+    )
+
+
+def line_chart_path(points: list[tuple[float, float]]) -> str:
+    if not points:
+        return ""
+    start = f"M {points[0][0]:.1f} {points[0][1]:.1f}"
+    rest = " ".join(f"L {x:.1f} {y:.1f}" for x, y in points[1:])
+    return f"{start} {rest}"
+
+
+def render_pipeline() -> None:
+    width, height = 1240, 560
+    nodes = [
+        ("Base model", "LiquidAI LFM2.5-8B-A1B", "BF16 MLX source", 34, 96, BLUE),
+        ("Mixed core", "Quantize MoE experts to int8", "Routers/non-experts stay BF16", 274, 96, TEAL),
+        ("Grouped training", "3 epochs, 1,746 steps", "overlapping groups g4/s3 at 10K cap", 514, 96, GREEN),
+        ("Direct checkpoint", "step_01746_final", "experts + routers changed", 754, 96, ORANGE),
+        ("Repair adapters", "Iter01 to Iter10 LoRA", "structured tool-call targets", 994, 96, PURPLE),
+        ("Parser-disabled evals", "MLX fixed-Hermes 43/43", "0 text-tool leaks", 274, 328, GREEN),
+        ("Export path", "Fuse + dequantize", "HF/safetensors source for GGUF", 514, 328, BLUE),
+        ("XL GGUF quants", "Q4/Q5/Q6/Q8 approx", "all pass 43-case llama.cpp eval", 754, 328, TEAL),
+    ]
+    body = header(
+        "End-to-end local Mac fine-tuning pipeline",
+        "Mixed int8-expert training creates the base behavioral change; LoRA repairs tool-call formatting and routing; GGUF export validates llama.cpp.",
+    )
+    body += '<defs><marker id="arrow" markerWidth="10" markerHeight="10" refX="9" refY="3" orient="auto"><path d="M0,0 L0,6 L9,3 z" fill="#94a3b8"/></marker></defs>'
+
+    arrows = [
+        (214, 172, 270, 172),
+        (454, 172, 510, 172),
+        (694, 172, 750, 172),
+        (934, 172, 990, 172),
+        (1084, 254, 420, 324),
+        (454, 404, 510, 404),
+        (694, 404, 750, 404),
+    ]
+    for x1, y1, x2, y2 in arrows:
+        body += f'<line x1="{x1}" y1="{y1}" x2="{x2}" y2="{y2}" stroke="#94a3b8" stroke-width="2" marker-end="url(#arrow)"/>'
+
+    for title, l1, l2, x, y, color in nodes:
+        body += f'<rect x="{x}" y="{y}" width="210" height="152" rx="8" fill="#f8fafc" stroke="{color}" stroke-width="2"/>'
+        body += f'<circle cx="{x+22}" cy="{y+25}" r="7" fill="{color}"/>'
+        body += f'<text x="{x+40}" y="{y+31}" class="node-title">{esc(title)}</text>'
+        body += f'<text x="{x+18}" y="{y+72}" class="node-text">{esc(l1)}</text>'
+        body += f'<text x="{x+18}" y="{y+96}" class="node-text">{esc(l2)}</text>'
+    write_svg(OUT / "pipeline_overview.svg", width, height, body)
+
+
+def render_group_sweep() -> None:
+    data = load_json("reports/group_sweep_10k.json")
+    rows = [r for r in data["results"] if r.get("ok")]
+    width, height = 980, 520
+    left, top, chart_w, chart_h = 72, 100, 820, 300
+    max_mem = max(r["peak_memory_gb"] for r in rows) * 1.08
+    max_time = max(r["elapsed_s"] for r in rows) * 1.08
+    x_step = chart_w / len(rows)
+    bar_w = 54
+    body = header(
+        "Group size sweep at 10K tokens",
+        "Larger simultaneous layer groups improve elapsed time, but group size 11 brushes the hard 60 GB limit.",
+    )
+    for i in range(0, 5):
+        y = top + chart_h - i * chart_h / 4
+        body += f'<line x1="{left}" y1="{y:.1f}" x2="{left+chart_w}" y2="{y:.1f}" class="axis"/>'
+        body += f'<text x="{left-10}" y="{y+4:.1f}" text-anchor="end" class="tick">{max_mem*i/4:.0f} GB</text>'
+    body += f'<line x1="{left}" y1="{top}" x2="{left}" y2="{top+chart_h}" stroke="{GRID}"/>'
+    body += f'<line x1="{left+chart_w}" y1="{top}" x2="{left+chart_w}" y2="{top+chart_h}" stroke="{GRID}"/>'
+
+    time_points = []
+    for idx, row in enumerate(rows):
+        cx = left + x_step * idx + x_step / 2
+        mem_h = chart_h * row["peak_memory_gb"] / max_mem
+        x = cx - bar_w / 2
+        y = top + chart_h - mem_h
+        fill = GREEN if row["group_size"] == data["recommended_group_size"] else BLUE
+        body += f'<rect x="{x:.1f}" y="{y:.1f}" width="{bar_w}" height="{mem_h:.1f}" rx="4" fill="{fill}" opacity="0.86"/>'
+        body += f'<text x="{cx:.1f}" y="{y-8:.1f}" text-anchor="middle" class="value">{row["peak_memory_gb"]:.1f}</text>'
+        body += f'<text x="{cx:.1f}" y="{top+chart_h+28}" text-anchor="middle" class="label">g{row["group_size"]}</text>'
+        ty = top + chart_h - chart_h * row["elapsed_s"] / max_time
+        time_points.append((cx, ty))
+    body += f'<path d="{line_chart_path(time_points)}" fill="none" stroke="{ORANGE}" stroke-width="3"/>'
+    for (cx, ty), row in zip(time_points, rows):
+        body += f'<circle cx="{cx:.1f}" cy="{ty:.1f}" r="5" fill="{ORANGE}"/>'
+        body += f'<text x="{cx:.1f}" y="{ty-12:.1f}" text-anchor="middle" class="small">{row["elapsed_s"]:.0f}s</text>'
+
+    body += f'<line x1="{left}" y1="{top+chart_h*(1-55/max_mem):.1f}" x2="{left+chart_w}" y2="{top+chart_h*(1-55/max_mem):.1f}" stroke="{GREEN}" stroke-dasharray="6 5" stroke-width="2"/>'
+    body += f'<line x1="{left}" y1="{top+chart_h*(1-60/max_mem):.1f}" x2="{left+chart_w}" y2="{top+chart_h*(1-60/max_mem):.1f}" stroke="{RED}" stroke-dasharray="6 5" stroke-width="2"/>'
+    body += f'<text x="{left+chart_w+12}" y="{top+chart_h*(1-55/max_mem)+4:.1f}" class="small">55 GB target</text>'
+    body += f'<text x="{left+chart_w+12}" y="{top+chart_h*(1-60/max_mem)+4:.1f}" class="small">60 GB hard stop</text>'
+    body += f'<rect x="{left}" y="{height-58}" width="14" height="14" fill="{BLUE}" opacity="0.86"/><text x="{left+22}" y="{height-46}" class="small">Peak memory, GB</text>'
+    body += f'<circle cx="{left+180}" cy="{height-51}" r="5" fill="{ORANGE}"/><text x="{left+192}" y="{height-46}" class="small">Elapsed seconds</text>'
+    body += f'<rect x="{left+332}" y="{height-58}" width="14" height="14" fill="{GREEN}" opacity="0.86"/><text x="{left+354}" y="{height-46}" class="small">Selected default group size</text>'
+    write_svg(OUT / "group_sweep_memory_time.svg", width, height, body)
+
+
+def render_dataset_filtering() -> None:
+    data = load_json("datasets/hermes_filtered_text_10k_manifest.json")["splits"]
+    width, height = 880, 460
+    left, top, chart_w, chart_h = 86, 100, 680, 260
+    labels = list(data.keys())
+    max_total = max(v["kept"] + v["dropped_from_16k_artifact"] for v in data.values())
+    body = header(
+        "10K token-cap dataset retained the shorter Hermes traces",
+        "The cap is per training example, not a total-token cap; longer rows were excluded from the 16K artifact.",
+    )
+    for i in range(5):
+        y = top + chart_h - i * chart_h / 4
+        body += f'<line x1="{left}" y1="{y:.1f}" x2="{left+chart_w}" y2="{y:.1f}" class="axis"/>'
+        body += f'<text x="{left-12}" y="{y+4:.1f}" text-anchor="end" class="tick">{max_total*i/4:.0f}</text>'
+    slot = chart_w / len(labels)
+    bar_w = 86
+    for idx, label in enumerate(labels):
+        kept = data[label]["kept"]
+        dropped = data[label]["dropped_from_16k_artifact"]
+        total = kept + dropped
+        x = left + idx * slot + slot / 2 - bar_w / 2
+        kept_h = chart_h * kept / max_total
+        drop_h = chart_h * dropped / max_total
+        y_kept = top + chart_h - kept_h
+        y_drop = y_kept - drop_h
+        body += f'<rect x="{x:.1f}" y="{y_drop:.1f}" width="{bar_w}" height="{drop_h:.1f}" fill="{ORANGE}" opacity="0.72"/>'
+        body += f'<rect x="{x:.1f}" y="{y_kept:.1f}" width="{bar_w}" height="{kept_h:.1f}" fill="{GREEN}" opacity="0.88"/>'
+        body += f'<text x="{x+bar_w/2:.1f}" y="{y_kept+18:.1f}" text-anchor="middle" class="value" fill="#fff">{kept}</text>'
+        body += f'<text x="{x+bar_w/2:.1f}" y="{y_drop-8:.1f}" text-anchor="middle" class="small">total {total}</text>'
+        body += f'<text x="{x+bar_w/2:.1f}" y="{top+chart_h+28}" text-anchor="middle" class="label">{esc(label)}</text>'
+    body += f'<rect x="{left}" y="{height-54}" width="14" height="14" fill="{GREEN}" opacity="0.88"/><text x="{left+22}" y="{height-42}" class="small">Kept at 10K cap</text>'
+    body += f'<rect x="{left+172}" y="{height-54}" width="14" height="14" fill="{ORANGE}" opacity="0.72"/><text x="{left+194}" y="{height-42}" class="small">Dropped from 16K artifact</text>'
+    write_svg(OUT / "dataset_filtering_10k.svg", width, height, body)
+
+
+def render_eval_progression() -> None:
+    colloquial = load_json("reports/colloquial_tool_router_repair_report.json")["eval_summaries"]
+    iter04 = colloquial["iter04_masked_colloquial_openai_parser_disabled"]
+    stages = [
+        ("Direct\ncheckpoint", 5, 6, 2, 3),
+        ("Iter01\nLoRA", 6, 6, 3, 3),
+        ("Iter04\ncolloquial", iter04["passed"], iter04["total"], iter04["structured_tool_cases_passed"], iter04["tool_cases"]),
+        ("Iter10\nfixed Hermes", 43, 43, 28, 28),
+        ("GGUF XL\nquants", 43, 43, 28, 28),
+    ]
+    width, height = 1020, 520
+    left, top, chart_w, chart_h = 78, 102, 820, 292
+    body = header(
+        "Tool-call reliability improved in stages",
+        "The broad colloquial loop exposed routing failures; structured fixed-Hermes data closed the release suite.",
+    )
+    for i in range(6):
+        y = top + chart_h - i * chart_h / 5
+        body += f'<line x1="{left}" y1="{y:.1f}" x2="{left+chart_w}" y2="{y:.1f}" class="axis"/>'
+        body += f'<text x="{left-12}" y="{y+4:.1f}" text-anchor="end" class="tick">{i*20}%</text>'
+    slot = chart_w / len(stages)
+    for idx, (label, passed, total, tool_passed, tool_total) in enumerate(stages):
+        cx = left + idx * slot + slot / 2
+        overall = passed / total
+        structured = tool_passed / tool_total
+        for j, (rate, color, val) in enumerate([(overall, BLUE, f"{passed}/{total}"), (structured, GREEN, f"{tool_passed}/{tool_total}")]):
+            bw = 44
+            x = cx - 50 + j * 56
+            h = chart_h * rate
+            y = top + chart_h - h
+            body += f'<rect x="{x:.1f}" y="{y:.1f}" width="{bw}" height="{h:.1f}" rx="4" fill="{color}" opacity="0.88"/>'
+            body += f'<text x="{x+bw/2:.1f}" y="{y-8:.1f}" text-anchor="middle" class="value">{val}</text>'
+        y0 = top + chart_h + 26
+        for line in label.split("\n"):
+            body += f'<text x="{cx:.1f}" y="{y0:.1f}" text-anchor="middle" class="small">{esc(line)}</text>'
+            y0 += 15
+    body += f'<rect x="{left}" y="{height-54}" width="14" height="14" fill="{BLUE}" opacity="0.88"/><text x="{left+22}" y="{height-42}" class="small">Overall pass rate</text>'
+    body += f'<rect x="{left+178}" y="{height-54}" width="14" height="14" fill="{GREEN}" opacity="0.88"/><text x="{left+200}" y="{height-42}" class="small">Structured tool-call pass rate</text>'
+    write_svg(OUT / "eval_progression.svg", width, height, body)
+
+
+def render_quant_size() -> None:
+    data = load_json("release_summary.json")
+    rows = []
+    for name, item in data["gguf_quants"].items():
+        if "Q4" in name:
+            label = "Q4_K_XL"
+        elif "Q5" in name:
+            label = "Q5_K_XL"
+        elif "Q6" in name:
+            label = "Q6_K_XL"
+        else:
+            label = "Q8_K_XL"
+        rows.append((label, item["bytes"] / 1024**3))
+    rows.sort(key=lambda x: x[1])
+    width, height = 900, 460
+    left, top, chart_w, chart_h = 90, 96, 680, 260
+    max_size = max(v for _, v in rows) * 1.16
+    body = header(
+        "GGUF XL approximation size/quality tradeoff",
+        "All four stock llama.cpp XL approximation quants passed the same 43-case fixed-Hermes suite at 64K context.",
+    )
+    for i in range(5):
+        y = top + chart_h - i * chart_h / 4
+        body += f'<line x1="{left}" y1="{y:.1f}" x2="{left+chart_w}" y2="{y:.1f}" class="axis"/>'
+        body += f'<text x="{left-12}" y="{y+4:.1f}" text-anchor="end" class="tick">{max_size*i/4:.1f} GiB</text>'
+    slot = chart_w / len(rows)
+    for idx, (label, gib) in enumerate(rows):
+        cx = left + idx * slot + slot / 2
+        h = chart_h * gib / max_size
+        x = cx - 48
+        y = top + chart_h - h
+        color = [GREEN, TEAL, BLUE, PURPLE][idx]
+        body += f'<rect x="{x:.1f}" y="{y:.1f}" width="96" height="{h:.1f}" rx="4" fill="{color}" opacity="0.88"/>'
+        body += f'<text x="{cx:.1f}" y="{y-10:.1f}" text-anchor="middle" class="value">{gib:.1f} GiB</text>'
+        body += f'<text x="{cx:.1f}" y="{top+chart_h+28}" text-anchor="middle" class="label">{esc(label)}</text>'
+        body += f'<text x="{cx:.1f}" y="{top+chart_h+48}" text-anchor="middle" class="small">43/43 pass</text>'
+    write_svg(OUT / "gguf_quant_size_quality.svg", width, height, body)
+
+
+def render_memory_model() -> None:
+    data = load_json("reports/memory_estimate.json")
+    stored = data["stored_weights_gb"]
+    gradients = data["training_gradient_pressure_gb"]
+    width, height = 980, 500
+    body = header(
+        "Why mixed quantization made local Mac training plausible",
+        "Storing experts as int8 reduces persistent weight size, but naive simultaneous gradients would still be too large.",
+    )
+    x0, y0 = 76, 128
+    max_w = 760
+    total = stored["total_estimate"][1]
+    parts = [
+        ("Experts int8", stored["experts_int8"], GREEN),
+        ("Non-experts BF16", stored["non_experts_bf16"], BLUE),
+        ("Scales/metadata", stored["scale_metadata_estimate"][1], ORANGE),
+    ]
+    body += f'<text x="{x0}" y="{y0-18}" class="label">Stored mixed checkpoint estimate: {total:.2f} GB</text>'
+    cur = x0
+    for label, value, color in parts:
+        w = max_w * value / total
+        body += f'<rect x="{cur:.1f}" y="{y0}" width="{w:.1f}" height="52" fill="{color}" opacity="0.86"/>'
+        body += f'<text x="{cur+w/2:.1f}" y="{y0+31}" text-anchor="middle" class="value" fill="#fff">{value:.2f} GB</text>'
+        cur += w
+    legend_y = y0 + 80
+    lx = x0
+    for label, _, color in parts:
+        body += f'<rect x="{lx}" y="{legend_y}" width="13" height="13" fill="{color}" opacity="0.86"/><text x="{lx+20}" y="{legend_y+11}" class="small">{esc(label)}</text>'
+        lx += 180
+
+    bars = [
+        ("Naive STE FP32 expert gradients", gradients["expert_grad_float32_if_naive_ste"], RED),
+        ("BF16 expert gradients if supported", gradients["expert_grad_bf16_if_supported"], ORANGE),
+        ("Compressed int8/sign update target", gradients["expert_grad_int8_sign_if_custom_optimizer"], GREEN),
+    ]
+    bx, by, bw_max, bh = 76, 286, 760, 34
+    max_g = max(v for _, v, _ in bars)
+    body += f'<text x="{bx}" y="{by-22}" class="label">Gradient/update pressure alternatives</text>'
+    for idx, (label, value, color) in enumerate(bars):
+        y = by + idx * 54
+        w = bw_max * value / max_g
+        body += f'<text x="{bx}" y="{y-6}" class="small">{esc(label)}</text>'
+        body += f'<rect x="{bx}" y="{y}" width="{w:.1f}" height="{bh}" rx="4" fill="{color}" opacity="0.82"/>'
+        body += f'<text x="{bx+w+10:.1f}" y="{y+23}" class="value">{value:.1f} GB</text>'
+    write_svg(OUT / "memory_model.svg", width, height, body)
+
+
+def render_category_eval() -> None:
+    summary = load_json("evals/iter10_fused_all_fixed_hermes_parser_disabled.json")["summary"]
+    metrics = summary["category_metrics"]
+    rows = [(k, v["passed"], v["total"]) for k, v in metrics.items()]
+    width, height = 900, 460
+    left, top, chart_w, chart_h = 80, 98, 690, 260
+    body = header(
+        "Fixed-Hermes parser-disabled eval coverage",
+        "The final fused MLX model passed browser, terminal, file, finalization, and no-tool categories with structured tool_calls.",
+    )
+    for i in range(6):
+        y = top + chart_h - i * chart_h / 5
+        body += f'<line x1="{left}" y1="{y:.1f}" x2="{left+chart_w}" y2="{y:.1f}" class="axis"/>'
+        body += f'<text x="{left-12}" y="{y+4:.1f}" text-anchor="end" class="tick">{i*20}%</text>'
+    slot = chart_w / len(rows)
+    for idx, (label, passed, total) in enumerate(rows):
+        rate = passed / total
+        cx = left + idx * slot + slot / 2
+        h = chart_h * rate
+        x = cx - 42
+        y = top + chart_h - h
+        body += f'<rect x="{x:.1f}" y="{y:.1f}" width="84" height="{h:.1f}" rx="4" fill="{BLUE}" opacity="0.86"/>'
+        body += f'<text x="{cx:.1f}" y="{y-9:.1f}" text-anchor="middle" class="value">{passed}/{total}</text>'
+        body += f'<text x="{cx:.1f}" y="{top+chart_h+28}" text-anchor="middle" class="label">{esc(label)}</text>'
+    write_svg(OUT / "fixed_hermes_category_eval.svg", width, height, body)
+
+
+def main() -> None:
+    render_pipeline()
+    render_group_sweep()
+    render_dataset_filtering()
+    render_eval_progression()
+    render_quant_size()
+    render_memory_model()
+    render_category_eval()
+    summary = {
+        "generated": [
+            "visuals/pipeline_overview.svg",
+            "visuals/group_sweep_memory_time.svg",
+            "visuals/dataset_filtering_10k.svg",
+            "visuals/eval_progression.svg",
+            "visuals/gguf_quant_size_quality.svg",
+            "visuals/memory_model.svg",
+            "visuals/fixed_hermes_category_eval.svg",
+        ],
+        "sources": [
+            "reports/group_sweep_10k.json",
+            "datasets/hermes_filtered_text_10k_manifest.json",
+            "reports/colloquial_tool_router_repair_report.json",
+            "release_summary.json",
+            "reports/memory_estimate.json",
+            "evals/iter10_fused_all_fixed_hermes_parser_disabled.json",
+        ],
+    }
+    (OUT / "visual_manifest.json").write_text(json.dumps(summary, indent=2), encoding="utf-8")
+
+
+if __name__ == "__main__":
+    main()

visuals/visual_manifest.json

@@ -0,0 +1,19 @@
+{
+  "generated": [
+    "visuals/pipeline_overview.svg",
+    "visuals/group_sweep_memory_time.svg",
+    "visuals/dataset_filtering_10k.svg",
+    "visuals/eval_progression.svg",
+    "visuals/gguf_quant_size_quality.svg",
+    "visuals/memory_model.svg",
+    "visuals/fixed_hermes_category_eval.svg"
+  ],
+  "sources": [
+    "reports/group_sweep_10k.json",
+    "datasets/hermes_filtered_text_10k_manifest.json",
+    "reports/colloquial_tool_router_repair_report.json",
+    "release_summary.json",
+    "reports/memory_estimate.json",
+    "evals/iter10_fused_all_fixed_hermes_parser_disabled.json"
+  ]
+}