@pikaa-ai/pikaa 0.2.5 → 0.3.1

package/skills/scientific-slides/scripts/validate_presentation.py

@@ -0,0 +1,408 @@
+#!/usr/bin/env python3
+"""
+Presentation Validation Script
+
+Validates scientific presentations for common issues:
+- Slide count vs. duration
+- LaTeX compilation
+- File size checks
+- Basic format validation
+"""
+
+import sys
+import os
+import argparse
+import subprocess
+from pathlib import Path
+from typing import Dict, List, Tuple, Optional
+
+# PDF page and geometry analysis. pypdf is the maintained continuation of
+# PyPDF2 and exposes the same PdfReader API, so accept whichever is installed.
+try:
+    from pypdf import PdfReader
+    HAS_PDF_READER = True
+except ImportError:
+    try:
+        from PyPDF2 import PdfReader
+        HAS_PDF_READER = True
+    except ImportError:
+        HAS_PDF_READER = False
+
+# Try to import python-pptx for PowerPoint analysis
+try:
+    from pptx import Presentation
+    HAS_PPTX = True
+except ImportError:
+    HAS_PPTX = False
+
+
+class PresentationValidator:
+    """Validates presentations for common issues."""
+    
+    # Recommended slide counts by duration (min, recommended, max)
+    SLIDE_GUIDELINES = {
+        5: (5, 6, 8),
+        10: (8, 11, 14),
+        15: (13, 16, 20),
+        20: (18, 22, 26),
+        30: (22, 27, 33),
+        45: (32, 40, 50),
+        60: (40, 52, 65),
+    }
+    
+    def __init__(self, filepath: str, duration: Optional[int] = None):
+        self.filepath = Path(filepath)
+        self.duration = duration
+        self.file_type = self.filepath.suffix.lower()
+        self.issues = []
+        self.warnings = []
+        self.info = []
+        
+    def validate(self) -> Dict:
+        """Run all validations and return results."""
+        print(f"Validating: {self.filepath.name}")
+        print(f"File type: {self.file_type}")
+        print("=" * 60)
+        
+        # Check file exists
+        if not self.filepath.exists():
+            self.issues.append(f"File not found: {self.filepath}")
+            return self._format_results()
+        
+        # File size check
+        self._check_file_size()
+        
+        # Type-specific validation
+        if self.file_type == '.pdf':
+            self._validate_pdf()
+        elif self.file_type in ['.pptx', '.ppt']:
+            self._validate_pptx()
+        elif self.file_type in ['.tex']:
+            self._validate_latex()
+        else:
+            self.warnings.append(f"Unknown file type: {self.file_type}")
+        
+        return self._format_results()
+    
+    def _check_file_size(self):
+        """Check if file size is reasonable."""
+        size_mb = self.filepath.stat().st_size / (1024 * 1024)
+        self.info.append(f"File size: {size_mb:.2f} MB")
+        
+        if size_mb > 100:
+            self.issues.append(
+                f"File is very large ({size_mb:.1f} MB). "
+                "Consider compressing images."
+            )
+        elif size_mb > 50:
+            self.warnings.append(
+                f"File is large ({size_mb:.1f} MB). "
+                "May be slow to email or upload."
+            )
+    
+    def _validate_pdf(self):
+        """Validate PDF presentation."""
+        if not HAS_PDF_READER:
+            self.warnings.append(
+                "pypdf not installed. Install with: uv pip install pypdf"
+            )
+            return
+
+        try:
+            with open(self.filepath, 'rb') as f:
+                reader = PdfReader(f)
+                num_pages = len(reader.pages)
+                
+                self.info.append(f"Number of slides: {num_pages}")
+                
+                # Check slide count against duration
+                if self.duration:
+                    self._check_slide_count(num_pages)
+                
+                # Get page size
+                first_page = reader.pages[0]
+                media_box = first_page.mediabox
+                width = float(media_box.width)
+                height = float(media_box.height)
+                
+                # Convert points to inches (72 points = 1 inch)
+                width_in = width / 72
+                height_in = height / 72
+                aspect = width / height
+                
+                self.info.append(
+                    f"Slide dimensions: {width_in:.1f}\" × {height_in:.1f}\" "
+                    f"(aspect ratio: {aspect:.2f})"
+                )
+                
+                # Check common aspect ratios
+                if abs(aspect - 16/9) < 0.01:
+                    self.info.append("Aspect ratio: 16:9 (widescreen)")
+                elif abs(aspect - 4/3) < 0.01:
+                    self.info.append("Aspect ratio: 4:3 (standard)")
+                else:
+                    self.warnings.append(
+                        f"Unusual aspect ratio: {aspect:.2f}. "
+                        "Confirm this matches venue requirements."
+                    )
+                
+        except Exception as e:
+            self.issues.append(f"Error reading PDF: {str(e)}")
+    
+    def _validate_pptx(self):
+        """Validate PowerPoint presentation."""
+        if not HAS_PPTX:
+            self.warnings.append(
+                "python-pptx not installed. Install with: uv pip install python-pptx"
+            )
+            return
+        
+        try:
+            prs = Presentation(self.filepath)
+            num_slides = len(prs.slides)
+            
+            self.info.append(f"Number of slides: {num_slides}")
+            
+            # Check slide count against duration
+            if self.duration:
+                self._check_slide_count(num_slides)
+            
+            # Get slide dimensions
+            width_inches = prs.slide_width / 914400  # EMU to inches
+            height_inches = prs.slide_height / 914400
+            aspect = prs.slide_width / prs.slide_height
+            
+            self.info.append(
+                f"Slide dimensions: {width_inches:.1f}\" × {height_inches:.1f}\" "
+                f"(aspect ratio: {aspect:.2f})"
+            )
+            
+            # Check fonts and text
+            self._check_pptx_content(prs)
+            
+        except Exception as e:
+            self.issues.append(f"Error reading PowerPoint: {str(e)}")
+    
+    def _check_pptx_content(self, prs):
+        """Check PowerPoint content for common issues."""
+        small_text_slides = []
+        many_bullets_slides = []
+        
+        for idx, slide in enumerate(prs.slides, start=1):
+            for shape in slide.shapes:
+                if not shape.has_text_frame:
+                    continue
+                
+                text_frame = shape.text_frame
+                
+                # Check for small fonts
+                for paragraph in text_frame.paragraphs:
+                    for run in paragraph.runs:
+                        if run.font.size and run.font.size.pt < 18:
+                            small_text_slides.append(idx)
+                            break
+                
+                # Check for too many bullets
+                bullet_count = sum(1 for p in text_frame.paragraphs if p.level == 0)
+                if bullet_count > 6:
+                    many_bullets_slides.append(idx)
+        
+        # Report issues
+        if small_text_slides:
+            unique_slides = sorted(set(small_text_slides))
+            self.warnings.append(
+                f"Small text (<18pt) found on slides: {unique_slides[:5]}"
+                + (" ..." if len(unique_slides) > 5 else "")
+            )
+        
+        if many_bullets_slides:
+            unique_slides = sorted(set(many_bullets_slides))
+            self.warnings.append(
+                f"Many bullets (>6) on slides: {unique_slides[:5]}"
+                + (" ..." if len(unique_slides) > 5 else "")
+            )
+    
+    def _validate_latex(self):
+        """Validate LaTeX Beamer presentation."""
+        self.info.append("LaTeX source file detected")
+        
+        # Try to compile
+        if self._try_compile_latex():
+            self.info.append("LaTeX compilation: SUCCESS")
+            
+            # If PDF was generated, validate it
+            pdf_path = self.filepath.with_suffix('.pdf')
+            if pdf_path.exists():
+                pdf_validator = PresentationValidator(str(pdf_path), self.duration)
+                pdf_results = pdf_validator.validate()
+                
+                # Merge results
+                self.info.extend(pdf_results['info'])
+                self.warnings.extend(pdf_results['warnings'])
+                self.issues.extend(pdf_results['issues'])
+        else:
+            self.issues.append(
+                "LaTeX compilation failed. Check .log file for errors."
+            )
+    
+    def _try_compile_latex(self) -> bool:
+        """Try to compile LaTeX file."""
+        try:
+            # Try pdflatex
+            result = subprocess.run(
+                ['pdflatex', '-no-shell-escape', '-interaction=nonstopmode', self.filepath.name],
+                cwd=self.filepath.parent,
+                capture_output=True,
+                timeout=60
+            )
+            return result.returncode == 0
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            return False
+    
+    def _check_slide_count(self, num_slides: int):
+        """Check if slide count is appropriate for duration."""
+        if self.duration not in self.SLIDE_GUIDELINES:
+            # Find nearest duration
+            durations = sorted(self.SLIDE_GUIDELINES.keys())
+            nearest = min(durations, key=lambda x: abs(x - self.duration))
+            min_slides, rec_slides, max_slides = self.SLIDE_GUIDELINES[nearest]
+            self.info.append(
+                f"Using guidelines for {nearest}-minute talk "
+                f"(closest to {self.duration} minutes)"
+            )
+        else:
+            min_slides, rec_slides, max_slides = self.SLIDE_GUIDELINES[self.duration]
+        
+        self.info.append(
+            f"Recommended slides for {self.duration}-minute talk: "
+            f"{min_slides}-{max_slides} (optimal: ~{rec_slides})"
+        )
+        
+        if num_slides < min_slides:
+            self.warnings.append(
+                f"Fewer slides ({num_slides}) than recommended ({min_slides}-{max_slides}). "
+                "May have too much time or too little content."
+            )
+        elif num_slides > max_slides:
+            self.warnings.append(
+                f"More slides ({num_slides}) than recommended ({min_slides}-{max_slides}). "
+                "Likely to run over time."
+            )
+        else:
+            self.info.append(
+                f"Slide count ({num_slides}) is within recommended range."
+            )
+    
+    def _format_results(self) -> Dict:
+        """Format validation results."""
+        return {
+            'filepath': str(self.filepath),
+            'file_type': self.file_type,
+            'info': self.info,
+            'warnings': self.warnings,
+            'issues': self.issues,
+            'valid': len(self.issues) == 0
+        }
+
+
+def print_results(results: Dict):
+    """Print validation results in a readable format."""
+    print()
+    print("=" * 60)
+    print("VALIDATION RESULTS")
+    print("=" * 60)
+    
+    # Print info
+    if results['info']:
+        print("\n📋 Information:")
+        for item in results['info']:
+            print(f"  • {item}")
+    
+    # Print warnings
+    if results['warnings']:
+        print("\n⚠️  Warnings:")
+        for item in results['warnings']:
+            print(f"  • {item}")
+    
+    # Print issues
+    if results['issues']:
+        print("\n❌ Issues:")
+        for item in results['issues']:
+            print(f"  • {item}")
+    
+    # Overall status
+    print("\n" + "=" * 60)
+    if results['valid']:
+        print("✅ Validation PASSED")
+        if results['warnings']:
+            print(f"   ({len(results['warnings'])} warning(s) found)")
+    else:
+        print("❌ Validation FAILED")
+        print(f"   ({len(results['issues'])} issue(s) found)")
+    print("=" * 60)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Validate scientific presentations',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s presentation.pdf --duration 15
+  %(prog)s slides.pptx --duration 45
+  %(prog)s beamer_talk.tex --duration 20
+
+Supported file types:
+  - PDF (.pdf)
+  - PowerPoint (.pptx, .ppt)
+  - LaTeX Beamer (.tex)
+
+Validation checks:
+  - Slide count vs. duration
+  - File size
+  - Slide dimensions
+  - Font sizes (PowerPoint)
+  - LaTeX compilation (Beamer)
+        """
+    )
+    
+    parser.add_argument(
+        'filepath',
+        help='Path to presentation file (PDF, PPTX, or TEX)'
+    )
+    
+    parser.add_argument(
+        '--duration', '-d',
+        type=int,
+        help='Presentation duration in minutes'
+    )
+    
+    parser.add_argument(
+        '--quiet', '-q',
+        action='store_true',
+        help='Only show issues and warnings'
+    )
+    
+    args = parser.parse_args()
+    
+    # Validate
+    validator = PresentationValidator(args.filepath, args.duration)
+    results = validator.validate()
+    
+    # Print results
+    if args.quiet:
+        # Only show warnings and issues
+        if results['warnings'] or results['issues']:
+            print_results(results)
+        else:
+            print("✅ No issues found")
+    else:
+        print_results(results)
+    
+    # Exit with appropriate code
+    sys.exit(0 if results['valid'] else 1)
+
+
+if __name__ == '__main__':
+    main()
+

package/skills/scientific-visualization/SKILL.md

@@ -0,0 +1,285 @@
+---
+name: scientific-visualization
+description: Create and audit truthful, accessible, publication-ready scientific figures with Matplotlib, Seaborn, or Plotly. Use for figure design, multi-panel layouts, uncertainty and missing-data displays, color/contrast review, image metadata validation, and journal export planning.
+license: MIT
+compatibility: Requires Python 3.11+ and uv for pinned examples. Bundled CLIs are network-free and load Matplotlib, Pillow, or pypdf only when needed. Plotly static export with Kaleido v1 requires a compatible Chrome/Chromium installation.
+allowed-tools: Read Write Edit Bash Glob Grep
+metadata:
+  version: "1.1"
+  skill-author: K-Dense Inc.
+---
+
+# Scientific Visualization
+
+Build figures that preserve scientific meaning before optimizing appearance. Separate universal principles from dated publisher rules, preserve raw data and transformations, use color redundantly, and inspect delivered files rather than trusting plotting defaults.
+
+## Non-negotiable guardrails
+
+- Never alter, hide, invent, or selectively enhance data to improve a figure.
+- Preserve raw tables/images, exclusions, missing-value codes, analysis code, normalization, binning, image adjustments, and random seeds.
+- Do not infer journal requirements. Identify the exact journal, article type, figure type, and submission phase; verify its live official guidance.
+- Do not claim that a palette, DPI value, format, or automated report makes a figure accessible or journal-compliant.
+- Do not silently connect missing observations, suppress inconvenient points, upsample images as if detail increased, or tune axes/dual axes to exaggerate a conclusion.
+- Keep interactive and static outputs as distinct deliverables. Interactive hover is not a substitute for labels, alt text, keyboard access, an accessible data table, or a static fallback.
+
+Read `references/publication_guidelines.md` for deceptive-encoding and integrity checks. Read `references/journal_requirements.md` only after the target and phase are known.
+
+## Workflow
+
+### 1. Define the evidence and destination
+
+Record:
+
+- audience and medium: manuscript, web, slide, poster, supplement;
+- exact publisher/journal, article type, submission phase, and intended final width;
+- variable semantics, units, sample/replicate structure, missing/censored values;
+- estimator and uncertainty definition;
+- transformations: filtering, aggregation, normalization, smoothing, bins, image processing;
+- source-data paths/identifiers and output provenance.
+
+If requirements are not known, create a provisional general figure and label all publisher choices as pending verification.
+
+### 2. Choose an honest encoding
+
+Prefer position on a common scale. Before coding, check:
+
+- **Bars/areas:** normally include zero because length/area is measured from a baseline.
+- **Points/lines:** nonzero limits can be valid; show context and disclose breaks.
+- **Uncertainty:** name SD, SE, CI, percentile, posterior, or another interval; state `n` and the unit of replication.
+- **Raw observations:** show them when feasible; do not let jitter obscure categories/values.
+- **Missing data:** distinguish missing, zero, censored, and excluded; use gaps or explicit model/interpolation styling.
+- **Area/volume:** scale area/volume, not radius/diameter; avoid decorative 3D.
+- **Log axes:** label the base/transform and declare how zero/negative values are handled.
+- **Binning/smoothing:** record edges, bandwidth/window, method, and sensitivity.
+- **Normalization:** state formula/reference and keep limits consistent across compared panels.
+- **Dual axes:** prefer aligned panels; if unavoidable, justify units and do not engineer apparent correlation.
+- **Images:** preserve originals, disclose whole-image adjustments, show scale bars, and avoid clipped/erased background.
+
+### 3. Design accessibility in, not after
+
+- Use color plus marker, line style, hatching, direct label, or panel separation.
+- Choose qualitative, sequential, diverging, or cyclic color according to data semantics.
+- Audit foreground/background contrast at the rendered size.
+- Make missing and out-of-range values explicit.
+- Provide alt text, a longer description for complex figures, and underlying data for web delivery.
+- Treat WCAG 2.2 as web guidance: 4.5:1 normal text, 3:1 large text, and 3:1 for graphical objects required for understanding; color cannot be the only cue. Applicability and exceptions matter.
+
+See `references/color_palettes.md`. A grayscale screen is useful but is not a complete color-vision or accessibility test.
+
+### 4. Implement with scoped styles
+
+Use Matplotlib's object-oriented API and temporary style contexts:
+
+```python
+import matplotlib.pyplot as plt
+
+from style_presets import style_context
+
+with style_context("default", palette_name="okabe_ito_on_white"):
+    fig, ax = plt.subplots(
+        figsize=(89 / 25.4, 60 / 25.4),
+        layout="constrained",
+    )
+    ax.plot(x, y, marker="o", label="Observed")
+    ax.set(xlabel="Time (hours)", ylabel="Response (unit)")
+    ax.legend()
+```
+
+`layout="constrained"` supports colorbars, nested GridSpec, subfigures, and `subplot_mosaic`. Do not call `tight_layout()` afterward; it disables constrained layout.
+
+For exact physical dimensions, do not use `bbox_inches="tight"` unless the changed page size is intentional.
+
+#### Color normalization
+
+```python
+import matplotlib as mpl
+
+norm = mpl.colors.TwoSlopeNorm(vmin=-2, vcenter=0, vmax=5)
+cmap = mpl.colormaps["RdBu_r"].with_extremes(bad="#777777")
+image = ax.imshow(values, norm=norm, cmap=cmap, interpolation="nearest")
+fig.colorbar(image, ax=ax, label="Change (unit)")
+```
+
+Use `LogNorm`, `CenteredNorm`, `SymLogNorm`, `BoundaryNorm`, or `TwoSlopeNorm` only when its mapping matches the scientific meaning.
+
+#### Seaborn
+
+Seaborn 0.13.2 uses the current `errorbar` API:
+
+```python
+sns.lineplot(
+    data=frame,
+    x="time",
+    y="response",
+    hue="treatment",
+    style="treatment",
+    markers=True,
+    errorbar=("ci", 95),
+    n_boot=5000,
+    seed=20260723,
+    ax=ax,
+)
+```
+
+Axes-level functions fit custom Matplotlib layouts; figure-level functions create their own figures/facets. Do not customize Seaborn's internal artist lists as if they were stable API.
+
+#### Plotly
+
+- Use `write_html()` for interaction and `write_image()`/`plotly.io.write_images()` for static output.
+- Kaleido 1.3.0 requires Chrome/Chromium; it no longer bundles Chrome.
+- Current static formats: PNG, JPEG, WebP, SVG, PDF. EPS is Kaleido v0-only.
+- Do not pass deprecated `engine=` or use Orca/`plotly.io.kaleido.scope`.
+- `width`, `height`, and `scale` control pixels; `scale=3` is not inherently “300 DPI.”
+- WebGL traces embed raster content in PDF/SVG.
+- Fully offline exports need local external assets when a figure references MathJax/topojson/tiles.
+
+### 5. Export explicitly and record provenance
+
+```python
+from figure_export import export_figure
+
+report = export_figure(
+    fig,
+    "outputs/figure1",
+    formats=["pdf", "png"],
+    dpi=600,
+    bbox_inches=None,  # preserve figure page dimensions
+    provenance={
+        "raw_data": "data/source.csv",
+        "transformations": ["predeclared QC filter", "group mean"],
+        "uncertainty": "95% bootstrap CI; seed 20260723",
+        "missing_data": "retained as gaps",
+    },
+    write_manifest=True,
+)
+```
+
+The exporter refuses implicit overwrite, writes atomically, keeps vector DPI for embedded rasters, uses TIFF LZW, and can use PDF/PS Type 42 fonts. It does not validate scientific content or publisher acceptance.
+
+For editable fonts:
+
+- PDF/PS Type 42 embeds TrueType fonts.
+- `svg.fonttype="none"` keeps text editable/searchable but does not embed fonts; appearance depends on installed fonts.
+- `svg.fonttype="path"` preserves glyph appearance as paths but loses editable/searchable text.
+
+Use an opaque explicit background unless transparency is required; blending against another background changes apparent contrast.
+
+### 6. Inspect, compare, and review
+
+1. Inspect file metadata.
+2. Audit palette contrast/grayscale separation.
+3. Compare against a dated publisher snapshot.
+4. View at final size in the manuscript/web context.
+5. Manually review fonts, embedded rasters, clipping, legends, scale bars, image integrity, caption, alt text, and source data.
+6. Re-check the live target-journal page immediately before upload.
+
+## Pinned snapshot
+
+The examples and smoke tests use direct package pins current on 2026-07-23:
+
+```bash
+uv run --isolated --no-project --python 3.13 \
+  --with "matplotlib==3.11.1" \
+  --with "seaborn==0.13.2" \
+  --with "plotly==6.9.0" \
+  --with "kaleido==1.3.0" \
+  --with "pillow==12.3.0" \
+  --with "pypdf==6.14.2" \
+  python your_figure.py
+```
+
+This is a dated direct-dependency snapshot, not a transitive lock. Use the project's uv lock for exact replay; this skill intentionally ships no dependency lock.
+
+## Bundled CLIs
+
+All helpers are deterministic, network-free, bounded, reject symlink inputs/destinations where relevant, and refuse overwrite unless `--force` is explicit.
+
+### Inspect raster/vector metadata
+
+```bash
+uv run --isolated --no-project --python 3.13 \
+  --with "pillow==12.3.0" \
+  python scripts/image_metadata.py figure.tiff \
+  --format tiff --mode RGB --min-dpi 300 --target-width-mm 85 \
+  --alpha-policy forbid
+```
+
+Supports raster images (Pillow), SVG, PDF (pypdf), and EPS/PS. Reports dimensions, DPI/effective DPI, mode, alpha, ICC presence, compression, page size, and conservative first-page PDF font resources. It does not inspect every embedded raster in a vector container.
+
+### Audit palette contrast and grayscale
+
+```bash
+uv run --isolated --no-project --python 3.13 \
+  python scripts/palette_audit.py \
+  --palette okabe_ito_on_white \
+  --background FFFFFF \
+  --role graphical
+```
+
+Reports exact WCAG sRGB contrast plus pairwise CIE L* grayscale screening. The grayscale threshold is a heuristic, not a standard.
+
+### Plan/screen publisher export
+
+```bash
+uv run --isolated --no-project --python 3.13 \
+  python scripts/export_plan.py \
+  --publisher nature \
+  --figure-type combination \
+  --width single \
+  --phase final
+```
+
+Add `--input figure.pdf` to screen machine-readable properties. Profiles are official-source snapshots accessed 2026-07-23, not automatic compliance rules.
+
+### Preview styles
+
+```bash
+uv run --isolated --no-project --python 3.13 \
+  --with "matplotlib==3.11.1" \
+  python scripts/style_preview.py \
+  --output outputs/style-preview \
+  --style default \
+  --palette okabe_ito_on_white \
+  --formats png,svg
+```
+
+### Inspect/write styles and smoke-test export
+
+```bash
+uv run --isolated --no-project --python 3.13 \
+  python scripts/style_presets.py --list
+uv run --isolated --no-project --python 3.13 \
+  python scripts/style_presets.py --show nature
+uv run --isolated --no-project --python 3.13 \
+  --with "matplotlib==3.11.1" \
+  python scripts/figure_export.py --demo outputs/export-smoke --manifest
+```
+
+## Assets
+
+- `assets/publication.mplstyle`: general print starting point.
+- `assets/nature.mplstyle`: dated flagship Nature visual starting point, not a compliance preset.
+- `assets/presentation.mplstyle`: larger projected-display style.
+- `assets/color_palettes.py`: importable Okabe-Ito and Paul Tol values with metadata.
+- `assets/publisher_profiles.json`: dated, machine-readable planning snapshots.
+
+Matplotlib style files omit `#` in hex colors because `#` begins comments in `.mplstyle` parsing.
+
+## References
+
+- `references/publication_guidelines.md`: integrity, deceptive encodings, accessibility, static/interactive output.
+- `references/color_palettes.md`: palette semantics, exact values, WCAG contrast, grayscale caveats, color management.
+- `references/journal_requirements.md`: phase-specific official publisher snapshots.
+- `references/matplotlib_examples.md`: current, runnable Matplotlib/Seaborn/Plotly patterns.
+- `references/sources.md`: official URLs, dates, versions, and research basis.
+
+## Final review checklist
+
+- [ ] Raw data/images and transformation code are preserved.
+- [ ] Missing values, exclusions, bins, normalization, and uncertainty are explicit.
+- [ ] Baselines, scales, limits, and area/volume encodings are honest.
+- [ ] Color is redundant and rendered contrast was reviewed.
+- [ ] Figure has an accessible description/data alternative where applicable.
+- [ ] Physical dimensions, DPI, format, fonts, transparency, and file size were inspected after export.
+- [ ] Publisher rules were verified for the exact journal and phase.
+- [ ] No automated report is presented as a scientific, accessibility, or compliance certification.