@researai/deepscientist 1.5.17 → 1.6.0

package/src/skills/paper-plot/references/line_confidence_band.md

@@ -0,0 +1,75 @@
+# Style: `line_confidence_band` (line chart with confidence-band shading)
+
+**Source paper**: Reinforcement learning via self-distillation  
+**Chart family**: Line chart with semi-transparent confidence bands  
+**Template script**: `repro/line_selfdistill.py`  
+**Original figures**: `image2.png` (continuous training curve), `image3.png` (discrete scaling curve)
+
+## Visual signature
+
+- **Colors**: green `#3A8B3A` for the main method, blue `#3B6BB5` for the comparison, gray `#999999` for the base model
+- **Band**: `fill_between` using the line color at `alpha=0.15`
+- **Line widths**: 1.8 for the main and comparison methods, 1.4 for the base model
+- **Markers**: filled circles on the discrete scaling variant
+- **Reference line**: gray dashed horizontal line for the continuous training-curve variant
+- **Typography**: LaTeX serif with the main legend entry in bold
+- **Spines**: keep left and bottom only for an open-axis look
+- **Grid**: none
+- **Legend**: unframed and placed inside the plot area
+
+## Key parameters
+
+```python
+plt.rcParams.update({
+    'text.usetex': True,
+    'font.family': 'serif',
+    'font.serif': ['Computer Modern Roman', 'STIX Two Text', 'DejaVu Serif'],
+})
+
+C_SDPO = '#3A8B3A'
+C_GRPO = '#3B6BB5'
+C_BASE = '#999999'
+
+ax.fill_between(x, mean - std, mean + std, color=C_SDPO, alpha=0.15)
+ax.plot(x, mean, color=C_SDPO, lw=1.8, label=r'\\textbf{SDPO}')
+
+for side, sp in ax.spines.items():
+    sp.set_visible(side in ('left', 'bottom'))
+
+leg = ax.legend(framealpha=0, edgecolor='none')
+for text in leg.get_texts():
+    if 'main method name' in text.get_text():
+        text.set_fontweight('bold')
+```
+
+## Variants
+
+### Type A: continuous training curve
+
+- x-axis uses training steps such as `0, 5k, 10k, 15k, 20k`
+- the confidence band usually narrows over time
+- legend is typically placed in the lower-right
+- a horizontal baseline reference line is usually present
+
+### Type B: discrete scaling curve
+
+- x-axis uses manually positioned labels for discrete model sizes
+- every point carries a visible circular marker
+- legend is typically in the upper-left
+- no reference line
+
+## Best use cases
+
+Use this style when the user provides:
+
+```python
+# Type A
+steps = np.linspace(0, 20000, 200)
+sdpo_mean = [...]
+sdpo_std = [...]
+
+# Type B
+param_labels = ['0.6B', '1.7B', '4B', '8B']
+sdpo_pts = [0.215, 0.333, 0.450, 0.490]
+sdpo_std = [0.005, 0.006, 0.008, 0.006]
+```

package/src/skills/paper-plot/references/line_loss_with_inset.md

@@ -0,0 +1,65 @@
+# Style: `line_loss_with_inset`
+
+## Best use case
+
+Training-loss curves where a local region must be magnified to show subtle differences through an inset panel.
+
+## Visual signature
+
+- Typeface: serif with `usetex=True` (Computer Modern-like)
+- Main panel: L-shaped spines (left and bottom only) with axis-end arrowheads
+- Inset: all four spines visible with a thicker border
+- Connectors: black dashed connection lines
+- Grid: light dotted grid on the main panel; no grid in the inset
+- Legend: upper-right with a white background and a very light gray frame
+
+## Color example
+
+```python
+C_ORANGE = '#FF7F0E'  # HybridNorm with spikes
+C_BLUE   = '#1F77B4'  # HybridNorm-ResiDual with higher noise
+C_GREEN  = '#2CA02C'  # SiameseNorm / smoother lower loss
+```
+
+## Key parameters
+
+```python
+# L-shaped main panel
+ax_main.spines['top'].set_visible(False)
+ax_main.spines['right'].set_visible(False)
+
+# Axis-end arrowheads
+ax_main.plot(1, 0, '>k', transform=ax_main.get_yaxis_transform(),
+             clip_on=False, markersize=5)
+ax_main.plot(0, 1, '^k', transform=ax_main.get_xaxis_transform(),
+             clip_on=False, markersize=5)
+
+# Zoom rectangle
+zoom_rect = mpatches.FancyBboxPatch(
+    (zoom_x1, zoom_y1), zoom_x2 - zoom_x1, zoom_y2 - zoom_y1,
+    boxstyle='square,pad=0', linewidth=1.0, edgecolor='#333333',
+    facecolor='none', linestyle='--', zorder=5)
+ax_main.add_patch(zoom_rect)
+
+# Connection line
+con = ConnectionPatch(
+    xyA=(zoom_x2, zoom_y2), coordsA=ax_main.transData,
+    xyB=(ax_inset.get_xlim()[0], ax_inset.get_ylim()[1]),
+    coordsB=ax_inset.transData,
+    color='#333333', lw=0.8, linestyle='--')
+fig.add_artist(con)
+
+# Legend
+ax_main.legend(loc='upper right', frameon=True,
+               facecolor='white', edgecolor='#DDDDDD', framealpha=1.0)
+```
+
+## Notes
+
+- The inset y-range should be chosen jointly from the zoom-box range and the local peak structure; avoid leaving large empty areas.
+- The main-panel y-axis does not need to start at zero if the source figure clearly uses a tighter value range.
+
+## Reference outputs
+
+- `repro/line_loss_inset.py`
+- `repro/line_loss_inset_repro.png`

package/src/skills/paper-plot/references/line_training_curve.md

@@ -0,0 +1,44 @@
+# Style: `line_training_curve`
+
+## Best use case
+
+Training-process curves comparing multiple methods, especially when the figure needs vertical breakpoint markers and a horizontal reference line.
+
+## Visual signature
+
+- Typeface: `sans-serif`, no LaTeX
+- Axis labels: roughly 12-13 pt and bold
+- Spines: all four visible
+- Tick direction: outward
+- Grid: none
+- Legend: lower-right with a white background and a gray frame
+
+## Color example
+
+```python
+C_DYN   = '#5B0DAD'  # deep purple for the main method
+C_NODYN = '#5BBCCA'  # soft teal for the comparison
+C_REF   = '#3D78C2'  # separate blue for the horizontal reference line
+```
+
+## Key parameters
+
+```python
+# Horizontal reference line
+ax.axhline(ref_y, color=C_REF, lw=1.5, linestyle='--')
+
+# Vertical breakpoint lines
+ax.axvline(step1, color=C_DYN, lw=1.5, linestyle='--', alpha=0.85)
+ax.axvline(step2, color=C_NODYN, lw=1.5, linestyle='--', alpha=0.85)
+
+# Full box + outward ticks
+for sp in ax.spines.values():
+    sp.set_visible(True)
+    sp.set_linewidth(1.0)
+ax.tick_params(direction='out', length=4, width=0.8)
+```
+
+## Reference outputs
+
+- `repro/line_aime.py`
+- `repro/line_aime_repro.png`

package/src/skills/paper-plot/references/radar_dual_series.md

@@ -0,0 +1,59 @@
+# Style: `radar_dual_series`
+
+## Best use case
+
+Radar / spider charts comparing two methods across several benchmark dimensions, with one method clearly highlighted.
+
+## Visual signature
+
+- Typeface: `sans-serif` (DejaVu Sans / Arial-like), no LaTeX
+- Axis labels: about 9 pt, regular weight, multi-line centered text
+- Value labels: about 8 pt, series-colored, rendered with white background boxes
+- Legend: outside the plot in the upper-left, with black text and colored short line segments
+- Grid: concentric **octagonal** dashed polygons, not circular approximations
+- Frame: `ax.set_frame_on(False)` for a clean polar plot
+- Fill: unified `alpha=0.18`
+- Line-width contrast: clearly thicker primary method line
+
+## Color example
+
+```python
+C_DORA = '#76A676'
+C_LORA = '#7D82FF'
+```
+
+## Key parameters
+
+```python
+fig, ax = plt.subplots(figsize=(8, 7.8), subplot_kw=dict(projection='polar'))
+ax.set_theta_zero_location('N')
+ax.set_theta_direction(-1)
+ax.set_yticks([])
+ax.set_xticks([])
+
+angles = np.linspace(0, 2 * np.pi, N, endpoint=False)
+for r in [0.4, 0.55, 0.7, 0.85, 1.0]:
+    ax.plot(close(angles), close(np.full(N, r)),
+            color='#CCCCCC', lw=0.8, linestyle='--')
+
+RMIN, RMAX = 0.35, 1.0
+def nrm(v, vmin, vmax):
+    return RMIN + (RMAX - RMIN) * (v - vmin) / (vmax - vmin)
+
+ax.fill(close(angles), close(dora_r), color=C_DORA, alpha=0.18)
+ax.plot(close(angles), close(dora_r), color=C_DORA, lw=2.8)
+ax.fill(close(angles), close(lora_r), color=C_LORA, alpha=0.18)
+ax.plot(close(angles), close(lora_r), color=C_LORA, lw=1.3)
+
+ax.text(
+    ang, r + 0.08, f'{v:.2f}',
+    ha='center', fontsize=7.8, color=C_DORA,
+    bbox=dict(boxstyle='round,pad=0.12', facecolor='white',
+              edgecolor='none', alpha=0.85)
+)
+```
+
+## Reference outputs
+
+- `repro/radar_dora.py`
+- `repro/radar_dora_repro.png`

package/src/skills/paper-plot/references/scatter_broken_axis.md

@@ -0,0 +1,59 @@
+# Style: `scatter_broken_axis`
+
+## Best use case
+
+Scatter plots comparing low-context (`0-50k`) and high-context (`115k`, `200k`) systems when the x-range is too discontinuous for a single unbroken axis.
+
+## Visual signature
+
+- Typeface: `sans-serif`, with bold axis labels around 13 pt
+- Spines: left panel is L-shaped, right panel keeps only the bottom spine
+- Axis break marks: only on the **bottom** x-axis edge, not on the top
+- Legend: lower-right, white background, light gray frame, six ordered entries
+- Marker outlines: main series use black outlines
+- Non-Pareto cloud: no outlines and slightly higher transparency
+
+## Color example
+
+```python
+C_PARETO    = '#E53935'
+C_NONPARETO = '#F4B8B8'
+C_DASH      = '#F0A0A0'
+C_FEW       = '#6B4FA0'
+C_FEW_LINE  = '#B8A8D8'
+C_MCE       = '#E69B00'
+C_ACE       = '#2E86C1'
+C_ZS        = '#5B2D8E'
+```
+
+## Key parameters
+
+```python
+fig, (ax1, ax2) = plt.subplots(
+    1, 2, figsize=(9.5, 5.5),
+    gridspec_kw={'width_ratios': [5, 1.3], 'wspace': 0.05},
+)
+
+d = 0.015
+kwargs = dict(transform=ax1.transAxes, color='k', clip_on=False, lw=1.2)
+ax1.plot((1 - d, 1 + d), (-d, +d), **kwargs)
+kwargs2 = dict(transform=ax2.transAxes, color='k', clip_on=False, lw=1.2)
+ax2.plot((-d, +d), (-d, +d), **kwargs2)
+
+ax1.spines['top'].set_visible(False)
+ax1.spines['right'].set_visible(False)
+ax2.spines[['top', 'right', 'left']].set_visible(False)
+
+ax1.legend(
+    handles=legend_elements,
+    loc='lower right',
+    frameon=True,
+    facecolor='white',
+    edgecolor='#CCCCCC',
+)
+```
+
+## Reference outputs
+
+- `repro/scatter_break.py`
+- `repro/scatter_break_repro.png`

package/src/skills/paper-plot/references/scatter_tsne_cluster.md

@@ -0,0 +1,72 @@
+# Style: `scatter_tsne_cluster`
+
+## Best use case
+
+t-SNE cluster visualizations for high-dimensional embeddings, especially when the plot needs many labeled clusters and annotation boxes.
+
+## Visual signature
+
+- Typeface: serif with `usetex=True` (Computer Modern-like); fall back to `STIX Two Text` when TeX is unavailable
+- Title: two bold lines around 13.5 pt
+- Axis labels: bold, around 12 pt
+- Ticks: regular, around 10 pt
+- Legend: upper-right, white background, light gray frame, small markers
+- Scatter cloud: `s=14`, `alpha=0.55`, no outlines, one color per cluster
+- Annotation boxes: rounded boxes with a shared dark border (`#2C3E50`) and a translucent fill derived from the cluster color
+- Grid: light dotted gray lines
+- Spines: all four visible in dark gray
+- Tick direction: inward
+
+## Color example
+
+```python
+DS_COLORS = {
+    'GSM8K': '#6A4C93',
+    'MATH': '#D651A0',
+    'GPQA': '#F06292',
+    'KodCode': '#FF8A65',
+    'BCB': '#FFB74D',
+    'ALFWorld': '#FFF176',
+    'TriviaQA': '#C888E8',
+}
+```
+
+## Key parameters
+
+```python
+plt.rcParams.update({
+    'text.usetex': True,
+    'font.family': 'serif',
+    'font.serif': ['Computer Modern Roman', 'STIX Two Text'],
+})
+
+ax.scatter(x, y, c=color, s=14, alpha=0.55, linewidths=0, rasterized=True)
+
+rgba = list(mcolors.to_rgba(color))
+rgba[3] = 0.28
+ax.annotate(
+    r'\\textbf{Name}', xy=...,
+    bbox=dict(
+        boxstyle='round,pad=0.30',
+        facecolor=tuple(rgba),
+        edgecolor='#2C3E50',
+        linewidth=0.9,
+    ),
+)
+
+ax.legend(frameon=True, facecolor='white', edgecolor='#CCCCCC',
+          markerscale=1.0, handlelength=0.8)
+
+for sp in ax.spines.values():
+    sp.set_visible(True)
+    sp.set_linewidth(0.9)
+    sp.set_color('#333333')
+
+ax.tick_params(direction='in', length=4, width=0.8)
+ax.grid(True, color='#E0E0E0', linewidth=0.6, linestyle=':', zorder=0)
+```
+
+## Reference outputs
+
+- `repro/scatter_tsne.py`
+- `repro/scatter_tsne_repro.png`

package/src/skills/paper-plot/scripts/bar_memevolve.py

@@ -0,0 +1,109 @@
+"""
+Reproduce image1: a MemEvolve-style paired bar chart.
+Features: paired bars (baseline vs. method), arrows, red percentage gain labels,
+and a dashed horizontal reference line.
+Source: MemEvolve: Meta-Evolution of Agent Memory Systems
+"""
+
+import matplotlib.pyplot as plt
+import matplotlib.patches as mpatches
+import matplotlib.ticker as ticker
+import numpy as np
+
+# ── Style summary ─────────────────────────────────────────
+# Typeface: serif, close to a Computer Modern look.
+# Weighting: title bold, delta labels bold, axis labels and ticks normal.
+# Spacing: the two bars are almost touching, with a very small gap.
+# Output target: 300 dpi.
+plt.rcParams.update({
+    'font.family': 'serif',
+    'font.serif': ['STIXGeneral', 'DejaVu Serif', 'Times New Roman'],
+    'mathtext.fontset': 'stix',
+})
+
+# ── Color system ─────────────────────────────────────────
+COLOR_BASELINE = '#A8C8E8'   # light steel blue for baseline bars
+COLOR_METHOD   = '#1B3D6E'   # deep navy for method bars
+COLOR_DELTA    = '#CC2200'   # red for gain annotations
+
+# ── Data ─────────────────────────────────────────────────
+panels = [
+    {
+        'title': 'OWL-Workforce',   # plain-text title; no emoji-dependent glyphs
+        'groups': ['Web', 'xBench', 'TaskCraft', 'GAIA'],
+        'baseline': [58.1, 55.2, 58.7, 59.3],
+        'method':   [62.3, 61.2, 65.5, 61.0],
+        'delta':    ['+7.1%', '+10.9%', '+11.9%', '+2.7%'],
+        'ylim':     (40, 71),   # left panel y-range matching the source figure
+    },
+    {
+        'title': 'CK-Pro',
+        'groups': ['Web', 'xBench', 'TaskCraft', 'GAIA'],
+        'baseline': [61.2, 55.8, 63.8, 58.1],
+        'method':   [63.8, 64.8, 67.8, 63.1],
+        'delta':    ['+4.2%', '+16.1%', '+4.8%', '+8.4%'],
+        'ylim':     (40, 76),   # right panel y-range matching the source figure
+    },
+]
+
+# ── Canvas ───────────────────────────────────────────────
+fig, axes = plt.subplots(1, 2, figsize=(10, 4.5), sharey=False)
+fig.subplots_adjust(wspace=0.35)
+
+BAR_W    = 0.28
+GAP      = 0.01      # the bars are nearly touching in the source figure
+ARROW_KW = dict(arrowstyle='->', color='black', lw=1.2)
+
+for ax, panel in zip(axes, panels):
+    groups   = panel['groups']
+    baseline = np.array(panel['baseline'])
+    method   = np.array(panel['method'])
+    delta    = panel['delta']
+    n        = len(groups)
+    x        = np.arange(n)
+
+    # Bars
+    bars_b = ax.bar(x - (BAR_W + GAP) / 2, baseline, width=BAR_W,
+                    color=COLOR_BASELINE, zorder=3)
+    bars_m = ax.bar(x + (BAR_W + GAP) / 2, method,   width=BAR_W,
+                    color=COLOR_METHOD,   zorder=3)
+
+    # Dashed reference line at the baseline height
+    for i, (bl, me) in enumerate(zip(baseline, method)):
+        # Horizontal dashed guide from the baseline bar top to the method bar top
+        ax.plot([x[i] - BAR_W, x[i] + BAR_W + GAP / 2],
+                [bl, bl], color='black', lw=0.9, ls='--', zorder=4)
+
+        # Arrow from the baseline top to the method top
+        ax.annotate('', xy=(x[i] + (BAR_W + GAP) / 2, me - 0.3),
+                    xytext=(x[i] + (BAR_W + GAP) / 2, bl + 0.3),
+                    arrowprops=ARROW_KW, zorder=5)
+
+        # Red percentage gain label
+        ax.text(x[i] + (BAR_W + GAP) / 2, me + 0.6,
+                delta[i], color=COLOR_DELTA,
+                ha='center', va='bottom', fontsize=9.5, fontweight='bold')
+
+    # Axis styling: the source figure uses clearly bold labels
+    ax.set_xticks(x)
+    ax.set_xticklabels(groups, fontsize=10.5, fontweight='bold')
+    ax.set_ylabel('Accuracy (Pass@1)', fontsize=10.5, fontweight='bold')
+    ax.set_ylim(*panel['ylim'])
+    ax.yaxis.set_major_locator(plt.MultipleLocator(5))
+
+    # All four spines stay visible with a slightly heavier frame
+    for spine in ax.spines.values():
+        spine.set_linewidth(1.5)
+        spine.set_color('black')
+    ax.tick_params(length=0)
+    ax.set_axisbelow(True)
+
+    # Upper-left title in bold serif and dark blue
+    ax.text(0.04, 0.97, panel['title'], transform=ax.transAxes,
+            fontsize=12, fontweight='bold', va='top', ha='left',
+            color='#003F6C', fontfamily='serif')
+
+plt.savefig('/Users/bytedance/gitcode/paper_experiment_plot_skills/repro/bar_memevolve_repro.png',
+            dpi=300, bbox_inches='tight', facecolor='white')
+plt.close()
+print('saved: bar_memevolve_repro.png')

package/src/skills/paper-plot/scripts/bar_spice.py

@@ -0,0 +1,166 @@
+"""
+Reproduce image5: a SPICE-style grouped bar chart.
+Features: grouped bars, hatched primary method, top value labels with a bold
+highlight for the best method, and a subtle gray grid.
+Source: SPICE: Self-play in corpus environments improves reasoning
+"""
+
+import matplotlib.pyplot as plt
+import matplotlib.patches as mpatches
+import numpy as np
+
+# ── Style summary ─────────────────────────────────────────
+# Typeface: closer to LaTeX / Computer Modern than to Times,
+# so the template enables usetex.
+# Weighting: panel titles normal, SPICE legend entry bold,
+# primary values bold and dark red, other values normal black.
+# Layout: slim three-bar groups with clear whitespace between groups.
+# Border: all spines remain visible and should stay visually above the bars.
+# Output target: 300 dpi.
+plt.rcParams.update({
+    'text.usetex': True,
+    'font.family': 'serif',
+    'font.serif': ['Computer Modern Roman', 'STIX Two Text', 'DejaVu Serif'],
+    'axes.unicode_minus': False,
+    'hatch.color': 'white',     # white hatch strokes over a red fill
+    'hatch.linewidth': 1.4,
+})
+
+# ── Colors & hatch settings ──────────────────────────────
+# Left panel (ablation)
+COLORS_ABL   = ['#FFB695', '#FF7F5E', '#D00000']   # light orange / mid orange / deep red
+HATCHES_ABL  = ['', '', '//']
+LABELS_ABL   = ['SPICE (Fixed Challenger)', 'SPICE (No Corpus)', 'SPICE']
+
+# Right panel (comparison)
+COLORS_CMP   = ['#D3D3D3', '#A9A9A9', '#D00000']   # light gray / mid gray / deep red
+HATCHES_CMP  = ['', '', '//']
+LABELS_CMP   = ['R-Zero', 'Absolute Zero', 'SPICE']
+
+# ── Data ─────────────────────────────────────────────────
+benchmarks = ['MATH500', "AIME'25", 'GPQA-Diamond', 'MMLU-Pro']
+
+data_abl = {
+    'SPICE (Fixed Challenger)': [68.2,  6.7, 26.3, 51.6],
+    'SPICE (No Corpus)':        [72.6, 12.3, 31.8, 53.7],
+    'SPICE':                    [78.0, 19.1, 39.4, 58.1],
+}
+data_cmp = {
+    'R-Zero':        [72.6,  5.2, 27.8, 53.7],
+    'Absolute Zero': [76.2, 13.4, 35.3, 52.6],
+    'SPICE':         [78.0, 19.1, 39.4, 58.1],
+}
+
+BEST_METHOD = 'SPICE'   # render this method's value labels in bold
+
+
+def draw_panel(
+    ax,
+    data_dict,
+    colors,
+    hatches,
+    labels,
+    title,
+    x_positions,
+    total_w,
+    xlim,
+    legend_anchor,
+):
+    n_groups  = len(benchmarks)
+    n_methods = len(labels)
+    x         = np.array(x_positions)
+    bar_w     = total_w / n_methods
+
+    for i, (label, color, hatch) in enumerate(zip(labels, colors, hatches)):
+        vals   = data_dict[label]
+        offset = (i - n_methods / 2 + 0.5) * bar_w
+        bars   = ax.bar(x + offset, vals, width=bar_w,
+                        color=color, hatch=hatch,
+                        edgecolor='white',
+                        linewidth=0.8, zorder=2, label=label)
+
+        is_best = (label == BEST_METHOD)
+        for bar, v in zip(bars, vals):
+            ax.text(bar.get_x() + bar.get_width() / 2,
+                    v + 0.5, f'{v}',
+                    ha='center', va='bottom',
+                    fontsize=8.7,
+                    fontweight='bold' if is_best else 'normal',
+                    color='black',   # keep values black; emphasis comes from font weight
+                    zorder=3)
+
+    # Axes
+    ax.set_xticks(x)
+    ax.set_xticklabels(benchmarks, fontsize=10.8)
+    ax.set_xlabel('Benchmark', fontsize=11.2)
+    ax.set_ylabel(r'Accuracy (\%)', fontsize=11.2)
+    ax.set_ylim(0, 85)
+    ax.set_xlim(*xlim)
+    ax.set_title(title, fontsize=13.2, pad=5)
+
+    # Grid (y-only, very light gray)
+    ax.yaxis.grid(True, color='#EBEBEB', linewidth=0.7, linestyle='--', zorder=0)
+    ax.set_axisbelow(True)
+
+    # Open-axis look: keep only the left and bottom spines
+    for side, spine in ax.spines.items():
+        if side in ('top', 'right'):
+            spine.set_visible(False)
+        else:
+            spine.set_linewidth(0.9)
+            spine.set_color('#333333')
+            spine.set_zorder(4)
+
+    ax.tick_params(length=0, labelsize=10.2)
+
+    # Legend
+    handles = [mpatches.Patch(facecolor=c, hatch=h,
+                               edgecolor='white', linewidth=0.8,
+                               label=l)
+               for l, c, h in zip(labels, colors, hatches)]
+    leg = ax.legend(handles=handles, fontsize=8.9, loc='upper right',
+                    bbox_to_anchor=legend_anchor,
+                    framealpha=1.0, facecolor='white',
+                    edgecolor='#C8C8C8', fancybox=False,
+                    borderpad=0.28, labelspacing=0.26,
+                    handlelength=1.7, handletextpad=0.45,
+                    borderaxespad=0.28)
+    # Only the primary method gets a bold legend label
+    for text in leg.get_texts():
+        if text.get_text() == BEST_METHOD:
+            text.set_fontweight('bold')
+
+
+# ── Canvas ───────────────────────────────────────────────
+fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12.8, 4.35))
+fig.subplots_adjust(left=0.05, right=0.985, bottom=0.15, top=0.86, wspace=0.16)
+
+draw_panel(
+    ax1,
+    data_abl,
+    COLORS_ABL,
+    HATCHES_ABL,
+    LABELS_ABL,
+    '(a) SPICE Ablations',
+    x_positions=[0.00, 1.00, 2.00, 3.00],
+    total_w=0.78,
+    xlim=(-0.56, 3.56),
+    legend_anchor=(0.992, 0.986),
+)
+draw_panel(
+    ax2,
+    data_cmp,
+    COLORS_CMP,
+    HATCHES_CMP,
+    LABELS_CMP,
+    '(b) SPICE vs Baselines',
+    x_positions=[0.00, 1.00, 2.00, 3.00],
+    total_w=0.78,
+    xlim=(-0.56, 3.56),
+    legend_anchor=(0.992, 0.986),
+)
+
+plt.savefig('/Users/bytedance/gitcode/paper_experiment_plot_skills/repro/bar_spice_repro.png',
+            dpi=300, facecolor='white')
+plt.close()
+print('saved: bar_spice_repro.png')