@_vrsen/openswarm 0.1.0

package/slides_agent/pptx/scripts/thumbnail.py

@@ -0,0 +1,451 @@
+#!/usr/bin/env python3
+"""
+Create thumbnail grids from PowerPoint presentation slides.
+
+Creates a grid layout of slide thumbnails with configurable columns (max 6).
+Each grid contains up to cols×(cols+1) images. For presentations with more
+slides, multiple numbered grid files are created automatically.
+
+The program outputs the names of all files created.
+
+Output:
+- Single grid: {prefix}.jpg (if slides fit in one grid)
+- Multiple grids: {prefix}-1.jpg, {prefix}-2.jpg, etc.
+
+Grid limits by column count:
+- 3 cols: max 12 slides per grid (3×4)
+- 4 cols: max 20 slides per grid (4×5)
+- 5 cols: max 30 slides per grid (5×6) [default]
+- 6 cols: max 42 slides per grid (6×7)
+
+Usage:
+    python thumbnail.py input.pptx [output_prefix] [--cols N] [--outline-placeholders]
+
+Examples:
+    python thumbnail.py presentation.pptx
+    # Creates: thumbnails.jpg (using default prefix)
+    # Outputs:
+    #   Created 1 grid(s):
+    #     - thumbnails.jpg
+
+    python thumbnail.py large-deck.pptx grid --cols 4
+    # Creates: grid-1.jpg, grid-2.jpg, grid-3.jpg
+    # Outputs:
+    #   Created 3 grid(s):
+    #     - grid-1.jpg
+    #     - grid-2.jpg
+    #     - grid-3.jpg
+
+    python thumbnail.py template.pptx analysis --outline-placeholders
+    # Creates thumbnail grids with red outlines around text placeholders
+"""
+
+import argparse
+import os
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+from inventory import extract_text_inventory
+from PIL import Image, ImageDraw
+from pptx import Presentation
+
+# Constants
+THUMBNAIL_WIDTH = 420  # Fixed thumbnail width in pixels
+CONVERSION_DPI = 100  # DPI for PDF to image conversion
+MAX_COLS = 6  # Maximum number of columns
+DEFAULT_COLS = 5  # Default number of columns
+JPEG_QUALITY = 95  # JPEG compression quality
+SOFFICE_TIMEOUT = 60  # Seconds for LibreOffice conversion
+PDFTOPPM_TIMEOUT = 60  # Seconds for Poppler rasterization
+
+# Grid layout constants
+GRID_PADDING = 20  # Padding between thumbnails
+BORDER_WIDTH = 2  # Border width around thumbnails
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Create thumbnail grids from PowerPoint slides."
+    )
+    parser.add_argument("input", help="Input PowerPoint file (.pptx)")
+    parser.add_argument(
+        "output_prefix",
+        nargs="?",
+        default="thumbnails",
+        help="Output prefix for image files (default: thumbnails, will create prefix.jpg or prefix-N.jpg)",
+    )
+    parser.add_argument(
+        "--cols",
+        type=int,
+        default=DEFAULT_COLS,
+        help=f"Number of columns (default: {DEFAULT_COLS}, max: {MAX_COLS})",
+    )
+    parser.add_argument(
+        "--outline-placeholders",
+        action="store_true",
+        help="Outline text placeholders with a colored border",
+    )
+
+    args = parser.parse_args()
+
+    # Validate columns
+    cols = min(args.cols, MAX_COLS)
+    if args.cols > MAX_COLS:
+        print(f"Warning: Columns limited to {MAX_COLS} (requested {args.cols})")
+
+    # Validate input
+    input_path = Path(args.input)
+    if not input_path.exists() or input_path.suffix.lower() != ".pptx":
+        print(f"Error: Invalid PowerPoint file: {args.input}")
+        sys.exit(1)
+
+    # Construct output path (always JPG)
+    output_path = Path(f"{args.output_prefix}.jpg")
+
+    print(f"Processing: {args.input}")
+
+    try:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Get placeholder regions if outlining is enabled
+            placeholder_regions = None
+            slide_dimensions = None
+            if args.outline_placeholders:
+                print("Extracting placeholder regions...")
+                placeholder_regions, slide_dimensions = get_placeholder_regions(
+                    input_path
+                )
+                if placeholder_regions:
+                    print(f"Found placeholders on {len(placeholder_regions)} slides")
+
+            # Convert slides to images
+            slide_images = convert_to_images(input_path, Path(temp_dir), CONVERSION_DPI)
+            if not slide_images:
+                print("Error: No slides found")
+                sys.exit(1)
+
+            print(f"Found {len(slide_images)} slides")
+
+            # Create grids (max cols×(cols+1) images per grid)
+            grid_files = create_grids(
+                slide_images,
+                cols,
+                THUMBNAIL_WIDTH,
+                output_path,
+                placeholder_regions,
+                slide_dimensions,
+            )
+
+            # Print saved files
+            print(f"Created {len(grid_files)} grid(s):")
+            for grid_file in grid_files:
+                print(f"  - {grid_file}")
+
+    except Exception as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+
+
+def create_hidden_slide_placeholder(size):
+    """Create placeholder image for hidden slides."""
+    img = Image.new("RGB", size, color="#F0F0F0")
+    draw = ImageDraw.Draw(img)
+    line_width = max(5, min(size) // 100)
+    draw.line([(0, 0), size], fill="#CCCCCC", width=line_width)
+    draw.line([(size[0], 0), (0, size[1])], fill="#CCCCCC", width=line_width)
+    return img
+
+
+def get_placeholder_regions(pptx_path):
+    """Extract ALL text regions from the presentation.
+
+    Returns a tuple of (placeholder_regions, slide_dimensions).
+    text_regions is a dict mapping slide indices to lists of text regions.
+    Each region is a dict with 'left', 'top', 'width', 'height' in inches.
+    slide_dimensions is a tuple of (width_inches, height_inches).
+    """
+    prs = Presentation(str(pptx_path))
+    inventory = extract_text_inventory(pptx_path, prs)
+    placeholder_regions = {}
+
+    # Get actual slide dimensions in inches (EMU to inches conversion)
+    slide_width_inches = (prs.slide_width or 9144000) / 914400.0
+    slide_height_inches = (prs.slide_height or 5143500) / 914400.0
+
+    for slide_key, shapes in inventory.items():
+        # Extract slide index from "slide-N" format
+        slide_idx = int(slide_key.split("-")[1])
+        regions = []
+
+        for shape_key, shape_data in shapes.items():
+            # The inventory only contains shapes with text, so all shapes should be highlighted
+            regions.append(
+                {
+                    "left": shape_data.left,
+                    "top": shape_data.top,
+                    "width": shape_data.width,
+                    "height": shape_data.height,
+                }
+            )
+
+        if regions:
+            placeholder_regions[slide_idx] = regions
+
+    return placeholder_regions, (slide_width_inches, slide_height_inches)
+
+
+def convert_to_images(pptx_path, temp_dir, dpi):
+    """Convert PowerPoint to images via PDF, handling hidden slides."""
+    # Detect hidden slides
+    print("Analyzing presentation...")
+    prs = Presentation(str(pptx_path))
+    total_slides = len(prs.slides)
+
+    # Find hidden slides (1-based indexing for display)
+    hidden_slides = {
+        idx + 1
+        for idx, slide in enumerate(prs.slides)
+        if slide.element.get("show") == "0"
+    }
+
+    print(f"Total slides: {total_slides}")
+    if hidden_slides:
+        print(f"Hidden slides: {sorted(hidden_slides)}")
+
+    pdf_path = temp_dir / f"{pptx_path.stem}.pdf"
+
+    # Convert to PDF
+    print("Converting to PDF...")
+    try:
+        kwargs = {
+            "capture_output": True,
+            "text": True,
+            "timeout": SOFFICE_TIMEOUT,
+            "input": "\n",
+        }
+        if os.name == "nt":
+            kwargs["creationflags"] = 0x08000000  # CREATE_NO_WINDOW
+
+        # On Windows, prefer soffice.com for CLI usage as it handles headless mode better than soffice.exe
+        soffice_bin = "soffice.com" if os.name == "nt" else "soffice"
+
+        result = subprocess.run(
+            [
+                soffice_bin,
+                "--headless",
+                "--convert-to",
+                "pdf",
+                "--outdir",
+                str(temp_dir),
+                str(pptx_path),
+            ],
+            **kwargs
+        )
+    except subprocess.TimeoutExpired as exc:
+        raise RuntimeError(f"PDF conversion timed out after {SOFFICE_TIMEOUT}s") from exc
+    if result.returncode != 0 or not pdf_path.exists():
+        raise RuntimeError("PDF conversion failed")
+
+    # Convert PDF to images
+    print(f"Converting to images at {dpi} DPI...")
+    try:
+        kwargs = {
+            "capture_output": True,
+            "text": True,
+            "timeout": PDFTOPPM_TIMEOUT,
+            "stdin": subprocess.DEVNULL,
+        }
+        if os.name == "nt":
+            kwargs["creationflags"] = 0x08000000  # CREATE_NO_WINDOW
+
+        result = subprocess.run(
+            ["pdftoppm", "-jpeg", "-r", str(dpi), str(pdf_path), str(temp_dir / "slide")],
+            **kwargs
+        )
+    except subprocess.TimeoutExpired as exc:
+        raise RuntimeError(
+            f"Image conversion timed out after {PDFTOPPM_TIMEOUT}s"
+        ) from exc
+    if result.returncode != 0:
+        raise RuntimeError("Image conversion failed")
+
+    visible_images = sorted(temp_dir.glob("slide-*.jpg"))
+
+    # Create full list with placeholders for hidden slides
+    all_images = []
+    visible_idx = 0
+
+    # Get placeholder dimensions from first visible slide
+    if visible_images:
+        with Image.open(visible_images[0]) as img:
+            placeholder_size = img.size
+    else:
+        placeholder_size = (1920, 1080)
+
+    for slide_num in range(1, total_slides + 1):
+        if slide_num in hidden_slides:
+            # Create placeholder image for hidden slide
+            placeholder_path = temp_dir / f"hidden-{slide_num:03d}.jpg"
+            placeholder_img = create_hidden_slide_placeholder(placeholder_size)
+            placeholder_img.save(placeholder_path, "JPEG")
+            all_images.append(placeholder_path)
+        else:
+            # Use the actual visible slide image
+            if visible_idx < len(visible_images):
+                all_images.append(visible_images[visible_idx])
+                visible_idx += 1
+
+    return all_images
+
+
+def create_grids(
+    image_paths,
+    cols,
+    width,
+    output_path,
+    placeholder_regions=None,
+    slide_dimensions=None,
+):
+    """Create multiple thumbnail grids from slide images, max cols×(cols+1) images per grid."""
+    # Maximum images per grid is cols × (cols + 1) for better proportions
+    max_images_per_grid = cols * (cols + 1)
+    grid_files = []
+
+    print(
+        f"Creating grids with {cols} columns (max {max_images_per_grid} images per grid)"
+    )
+
+    # Split images into chunks
+    for chunk_idx, start_idx in enumerate(
+        range(0, len(image_paths), max_images_per_grid)
+    ):
+        end_idx = min(start_idx + max_images_per_grid, len(image_paths))
+        chunk_images = image_paths[start_idx:end_idx]
+
+        # Create grid for this chunk
+        grid = create_grid(
+            chunk_images, cols, width, start_idx, placeholder_regions, slide_dimensions
+        )
+
+        # Generate output filename
+        if len(image_paths) <= max_images_per_grid:
+            # Single grid - use base filename without suffix
+            grid_filename = output_path
+        else:
+            # Multiple grids - insert index before extension with dash
+            stem = output_path.stem
+            suffix = output_path.suffix
+            grid_filename = output_path.parent / f"{stem}-{chunk_idx + 1}{suffix}"
+
+        # Save grid
+        grid_filename.parent.mkdir(parents=True, exist_ok=True)
+        grid.save(str(grid_filename), quality=JPEG_QUALITY)
+        grid_files.append(str(grid_filename))
+
+    return grid_files
+
+
+def create_grid(
+    image_paths,
+    cols,
+    width,
+    start_slide_num=0,
+    placeholder_regions=None,
+    slide_dimensions=None,
+):
+    """Create thumbnail grid from slide images with optional placeholder outlining."""
+    # Get dimensions
+    with Image.open(image_paths[0]) as img:
+        aspect = img.height / img.width
+    height = int(width * aspect)
+
+    # Calculate grid size
+    rows = (len(image_paths) + cols - 1) // cols
+    grid_w = cols * width + (cols + 1) * GRID_PADDING
+    grid_h = rows * height + (rows + 1) * GRID_PADDING
+
+    # Create grid
+    grid = Image.new("RGB", (grid_w, grid_h), "white")
+    draw = ImageDraw.Draw(grid)
+
+    # Place thumbnails
+    for i, img_path in enumerate(image_paths):
+        row, col = i // cols, i % cols
+        x = col * width + (col + 1) * GRID_PADDING
+        y_thumbnail = row * height + (row + 1) * GRID_PADDING
+
+        with Image.open(img_path) as img:
+            # Get original dimensions before thumbnail
+            orig_w, orig_h = img.size
+
+            # Apply placeholder outlines if enabled
+            if placeholder_regions and (start_slide_num + i) in placeholder_regions:
+                # Convert to RGBA for transparency support
+                if img.mode != "RGBA":
+                    img = img.convert("RGBA")
+
+                # Get the regions for this slide
+                regions = placeholder_regions[start_slide_num + i]
+
+                # Calculate scale factors using actual slide dimensions
+                if slide_dimensions:
+                    slide_width_inches, slide_height_inches = slide_dimensions
+                else:
+                    # Fallback: estimate from image size at CONVERSION_DPI
+                    slide_width_inches = orig_w / CONVERSION_DPI
+                    slide_height_inches = orig_h / CONVERSION_DPI
+
+                x_scale = orig_w / slide_width_inches
+                y_scale = orig_h / slide_height_inches
+
+                # Create a highlight overlay
+                overlay = Image.new("RGBA", img.size, (255, 255, 255, 0))
+                overlay_draw = ImageDraw.Draw(overlay)
+
+                # Highlight each placeholder region
+                for region in regions:
+                    # Convert from inches to pixels in the original image
+                    px_left = int(region["left"] * x_scale)
+                    px_top = int(region["top"] * y_scale)
+                    px_width = int(region["width"] * x_scale)
+                    px_height = int(region["height"] * y_scale)
+
+                    # Draw highlight outline with red color and thick stroke
+                    # Using a bright red outline instead of fill
+                    stroke_width = max(
+                        5, min(orig_w, orig_h) // 150
+                    )  # Thicker proportional stroke width
+                    overlay_draw.rectangle(
+                        [(px_left, px_top), (px_left + px_width, px_top + px_height)],
+                        outline=(255, 0, 0, 255),  # Bright red, fully opaque
+                        width=stroke_width,
+                    )
+
+                # Composite the overlay onto the image using alpha blending
+                img = Image.alpha_composite(img, overlay)
+                # Convert back to RGB for JPEG saving
+                img = img.convert("RGB")
+
+            img.thumbnail((width, height), Image.Resampling.LANCZOS)
+            w, h = img.size
+            tx = x + (width - w) // 2
+            ty = y_thumbnail + (height - h) // 2
+            grid.paste(img, (tx, ty))
+
+            # Add border
+            if BORDER_WIDTH > 0:
+                draw.rectangle(
+                    [
+                        (tx - BORDER_WIDTH, ty - BORDER_WIDTH),
+                        (tx + w + BORDER_WIDTH - 1, ty + h + BORDER_WIDTH - 1),
+                    ],
+                    outline="gray",
+                    width=BORDER_WIDTH,
+                )
+
+    return grid
+
+
+if __name__ == "__main__":
+    main()

package/slides_agent/slides_agent.py

@@ -0,0 +1,109 @@
+from agency_swarm import Agent, ModelSettings
+from agency_swarm.tools import IPythonInterpreter, PersistentShellTool, LoadFileAttachment, WebSearchTool
+from datetime import datetime, timezone
+from openai.types.shared import Reasoning
+from pathlib import Path
+from virtual_assistant.tools.ReadFile import ReadFile
+
+from config import get_default_model, is_openai_provider
+
+# Import slide tools
+from .tools import (
+    InsertNewSlides,
+    ModifySlide,
+    ManageTheme,
+    DeleteSlide,
+    SlideScreenshot,
+    ReadSlide,
+    BuildPptxFromHtmlSlides,
+    RestoreSnapshot,
+    CreatePptxThumbnailGrid,
+    CheckSlideCanvasOverflow,
+    CheckSlide,
+    DownloadImage,
+    EnsureRasterImage,
+    # ExtractPptxTextInventory,
+    # RearrangePptxSlidesFromTemplate,
+    # ApplyPptxTextReplacements,
+    ImageSearch,
+    GenerateImage,
+)
+
+_INSTRUCTIONS_PATH = Path(__file__).parent / "instructions.md"
+
+
+def _list_existing_projects() -> str:
+    from .tools.slide_file_utils import get_mnt_dir
+    base = get_mnt_dir()
+    if not base.exists():
+        return "(none)"
+    dirs = sorted(d.name for d in base.iterdir() if d.is_dir())
+    return "\n".join(f"  - {d}" for d in dirs) if dirs else "(none)"
+
+
+def _build_instructions() -> str:
+    now_utc = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M UTC")
+    body = _INSTRUCTIONS_PATH.read_text(encoding="utf-8")
+    projects_block = _list_existing_projects()
+    return (
+        f"{body}\n\n"
+        f"Current date/time (UTC): {now_utc}\n\n"
+        f"Existing project folders (do NOT reuse these names for a new presentation):\n{projects_block}"
+    )
+
+
+def create_slides_agent() -> Agent:
+    return Agent(
+        name="Slides Agent",
+        description="PowerPoint presentation specialist for creating, editing, and analyzing .pptx files",
+        instructions=_build_instructions(),
+        # files_folder=os.path.join(current_dir, "files"),
+        # tools_folder=os.path.join(current_dir, "tools"),
+        tools=[
+            # Slide creation and management: InsertNewSlides then ModifySlide
+            InsertNewSlides,
+            ModifySlide,
+            ManageTheme,
+            DeleteSlide,
+            SlideScreenshot,
+            ReadSlide,
+            # PPTX building
+            BuildPptxFromHtmlSlides,
+            RestoreSnapshot,
+            CreatePptxThumbnailGrid,
+            CheckSlideCanvasOverflow,
+            CheckSlide,
+            # Image download
+            DownloadImage,
+            EnsureRasterImage,
+            GenerateImage,
+            # Template-based editing
+            # ExtractPptxTextInventory,
+            # RearrangePptxSlidesFromTemplate,
+            # ApplyPptxTextReplacements,
+            ImageSearch,
+            # Utility tools
+            IPythonInterpreter,
+            PersistentShellTool,
+            LoadFileAttachment,
+            ReadFile,
+            WebSearchTool(search_context_size="high"),
+        ],
+        model=get_default_model(),
+        model_settings=ModelSettings(
+            reasoning=Reasoning(effort="high", summary="auto") if is_openai_provider() else None,
+            verbosity="medium" if is_openai_provider() else None,
+            response_include=["web_search_call.action.sources"] if is_openai_provider() else None,
+        ),
+        conversation_starters=[
+            "Create a new presentation about the benefits of using AI in the workplace.",
+            "Edit my existing presentation and improve the design.",
+            "Create a pitch deck for my startup idea.",
+            "Turn this document into a professional slide deck.",
+        ],
+    )
+
+
+if __name__ == "__main__":
+    from agency_swarm import Agency
+    Agency(create_slides_agent()).terminal_demo(reload=False)

package/slides_agent/test_deck/_theme.css

@@ -0,0 +1,92 @@
+:root {
+  --bg: #F7F4EF;
+  --ink: #141518;
+  --muted: #5B606A;
+  --accent: #E36A2E;
+  --card: #FFFFFF;
+  --line: #D7D1C7;
+  --dark: #0F0F10;
+ }
+ 
+ * { box-sizing: border-box; }
+ body {
+  margin: 0;
+  background: var(--bg);
+  color: var(--ink);
+  font-family: "Inter", Helvetica, Arial, sans-serif;
+ }
+ h1, h2, h3, p, ul, ol { margin: 0; }
+ 
+ h1 { font-size: 56px; line-height: 1.05; font-weight: 800; letter-spacing: -0.4px; }
+ h2 { font-size: 36px; line-height: 1.12; font-weight: 800; letter-spacing: -0.25px; }
+ h3 { font-size: 24px; line-height: 1.18; font-weight: 800; }
+ p { font-size: 20px; line-height: 1.35; color: var(--ink); }
+ 
+ .small { font-size: 16px; line-height: 1.35; color: var(--muted); }
+ .kicker { font-size: 16px; letter-spacing: 2px; font-weight: 800; color: var(--accent); }
+ 
+ .canvas {
+  width: 100%;
+  height: 100%;
+  padding: 32px 32px 48px 32px;
+  overflow: hidden;
+ }
+ 
+ .title-block { display: flex; flex-direction: column; gap: 24px; }
+ .subtitle { font-size: 28px; line-height: 1.35; color: var(--muted); }
+ .footer { position: absolute; left: 32px; right: 32px; bottom: 48px; }
+
+ .font-serif { font-family: "Merriweather", serif; }
+ .font-sans { font-family: "Inter", sans-serif; }
+ .font-mono { font-family: "Roboto Mono", monospace; }
+ 
+ .split { display: flex; gap: 32px; height: 100%; }
+ .leftPanel {
+  width: 420px;
+  background: var(--dark);
+  color: #FFFFFF;
+  border-radius: 20px;
+  padding: 32px;
+  display: flex;
+  flex-direction: column;
+  justify-content: space-between;
+ }
+ .leftPanel h1, .leftPanel h2, .leftPanel h3, .leftPanel p { color: #FFFFFF; }
+ .rightPanel {
+  flex: 1;
+  background: var(--card);
+  border: 2px solid var(--line);
+  border-radius: 20px;
+  padding: 32px;
+  display: flex;
+  flex-direction: column;
+  gap: 20px;
+ }
+ 
+ .image-frame {
+  width: 100%;
+  height: 360px;
+  border-radius: 16px;
+  overflow: hidden;
+  border: 2px solid var(--line);
+  background: #FFFFFF;
+ }
+ .image-frame img {
+  width: 100%;
+  height: 100%;
+  object-fit: cover;
+ }
+ 
+ .kpi-row { display: flex; gap: 20px; margin-top: 24px; }
+ .kpi-card {
+  flex: 1;
+  background: var(--card);
+  border: 2px solid var(--line);
+  border-radius: 16px;
+  padding: 20px;
+ }
+ .kpi-value { font-size: 48px; font-weight: 800; color: var(--dark); }
+ .kpi-label { font-size: 18px; color: var(--muted); }
+ 
+ ul { padding-left: 22px; }
+ ul li { font-size: 18px; line-height: 1.35; margin: 8px 0; }

package/slides_agent/test_deck/assets/placeholder.svg

@@ -0,0 +1,11 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="1200" height="800" viewBox="0 0 1200 800">
+  <rect width="1200" height="800" fill="#F2EEE8"/>
+  <rect x="40" y="40" width="1120" height="720" fill="#FFFFFF" stroke="#D7D1C7" stroke-width="6" rx="24"/>
+  <circle cx="220" cy="240" r="70" fill="#E36A2E" opacity="0.85"/>
+  <rect x="340" y="200" width="700" height="22" fill="#141518" opacity="0.85"/>
+  <rect x="340" y="250" width="560" height="18" fill="#5B606A" opacity="0.7"/>
+  <rect x="340" y="300" width="620" height="18" fill="#5B606A" opacity="0.6"/>
+  <rect x="140" y="430" width="920" height="180" fill="#F7F4EF" stroke="#D7D1C7" stroke-width="4" rx="16"/>
+  <text x="600" y="520" text-anchor="middle" font-family="Arial, Helvetica, sans-serif" font-size="36" fill="#141518">Image Placeholder</text>
+  <text x="600" y="570" text-anchor="middle" font-family="Arial, Helvetica, sans-serif" font-size="22" fill="#5B606A">Replace with a real visual</text>
+</svg>

package/slides_agent/test_deck/slide_01_title.html

@@ -0,0 +1,10 @@
+<div class="canvas">
+  <div class="title-block">
+    <p class="kicker">TEST DECK</p>
+    <h1>Slides Agent Layout Smoke Test</h1>
+    <p class="subtitle">Full-size 1280x720 canvas with safe margins.</p>
+  </div>
+  <div class="footer">
+    <p class="small">Internal QA deck • Includes image and KPI layouts</p>
+  </div>
+</div>

package/slides_agent/test_deck/slide_02_image_split.html

@@ -0,0 +1,23 @@
+<div class="canvas">
+  <div class="split">
+    <div class="leftPanel">
+      <div>
+        <p class="kicker">VISUAL</p>
+        <h2>Image-led split layout</h2>
+        <p class="small">Use real imagery and keep explicit sizing.</p>
+      </div>
+      <ul>
+        <li>Image fills a framed container</li>
+        <li>Text stays inside fixed panels</li>
+        <li>No overlap or overflow</li>
+      </ul>
+      <p class="small">Inline SVG or image icons only</p>
+    </div>
+    <div class="rightPanel">
+      <div class="image-frame">
+        <img src="./assets/placeholder.svg" alt="Placeholder image" />
+      </div>
+      <p class="small">Example: product mockup or market photo</p>
+    </div>
+  </div>
+</div>