@prismer/runtime 2.2.55 → 2.2.64

package/built-in-skills/skill-creator/scripts/improve_description.py

@@ -12,9 +12,13 @@ import os
 import re
 import subprocess
 import sys
+import tempfile
 from pathlib import Path
 
-from scripts.utils import parse_skill_md
+if __package__:
+    from .utils import parse_skill_md
+else:
+    from utils import parse_skill_md
 
 
 def _call_claude(prompt: str, model: str | None, timeout: int = 300) -> str:
@@ -23,26 +27,20 @@ def _call_claude(prompt: str, model: str | None, timeout: int = 300) -> str:
     Prompt goes over stdin (not argv) because it embeds the full SKILL.md
     body and can easily exceed comfortable argv length.
     """
-    cmd = ["claude", "-p", "--output-format", "text"]
+    if os.environ.get('PRISMER_ALLOW_PAID_EVAL') != '1':
+        raise PermissionError('Set PRISMER_ALLOW_PAID_EVAL=1 after approving evaluation cost')
+    cmd = ['claude', '-p', '--output-format', 'text', '--bare', '--tools', '',
+           '--strict-mcp-config', '--mcp-config', '{"mcpServers":{}}',
+           '--setting-sources', '', '--no-session-persistence', '--max-budget-usd', '0.25']
     if model:
         cmd.extend(["--model", model])
 
-    # Remove CLAUDECODE env var to allow nesting claude -p inside a
-    # Claude Code session. The guard is for interactive terminal conflicts;
-    # programmatic subprocess usage is safe. Same pattern as run_eval.py.
-    env = {k: v for k, v in os.environ.items() if k != "CLAUDECODE"}
-
-    result = subprocess.run(
-        cmd,
-        input=prompt,
-        capture_output=True,
-        text=True,
-        env=env,
-        timeout=timeout,
-    )
+    with tempfile.TemporaryDirectory(prefix='skill-description-') as directory:
+        result = subprocess.run(cmd, input=prompt, capture_output=True, text=True,
+                                env=dict(os.environ), cwd=directory, timeout=timeout)
     if result.returncode != 0:
         raise RuntimeError(
-            f"claude -p exited {result.returncode}\nstderr: {result.stderr}"
+            f"claude -p exited {result.returncode}; evaluation incomplete"
         )
     return result.stdout
 

package/built-in-skills/skill-creator/scripts/package_skill.py

@@ -3,23 +3,26 @@
 Skill Packager - Creates a distributable .skill file of a skill folder
 
 Usage:
-    python utils/package_skill.py <path/to/skill-folder> [output-directory]
+    python scripts/package_skill.py <path/to/skill-folder> [output-directory]
 
 Example:
-    python utils/package_skill.py skills/public/my-skill
-    python utils/package_skill.py skills/public/my-skill ./dist
+    python scripts/package_skill.py skills/public/my-skill
+    python scripts/package_skill.py skills/public/my-skill ./dist
 """
 
 import fnmatch
 import sys
 import zipfile
 from pathlib import Path
-from scripts.quick_validate import validate_skill
+if __package__:
+    from .quick_validate import validate_skill
+else:
+    from quick_validate import validate_skill
 
 # Patterns to exclude when packaging skills.
-EXCLUDE_DIRS = {"__pycache__", "node_modules"}
+EXCLUDE_DIRS = {"__pycache__", "node_modules", ".git", ".prismer"}
 EXCLUDE_GLOBS = {"*.pyc"}
-EXCLUDE_FILES = {".DS_Store"}
+EXCLUDE_FILES = {".DS_Store", ".env"}
 # Directories excluded only at the skill root (not when nested deeper).
 ROOT_EXCLUDE_DIRS = {"evals"}
 
@@ -91,6 +94,10 @@ def package_skill(skill_path, output_dir=None):
         with zipfile.ZipFile(skill_filename, 'w', zipfile.ZIP_DEFLATED) as zipf:
             # Walk through the skill directory, excluding build artifacts
             for file_path in skill_path.rglob('*'):
+                if file_path.is_symlink():
+                    raise ValueError(f'Symlink is not a portable bundle resource: {file_path}')
+                if file_path.resolve() == skill_filename.resolve():
+                    continue
                 if not file_path.is_file():
                     continue
                 arcname = file_path.relative_to(skill_path.parent)
@@ -110,10 +117,10 @@ def package_skill(skill_path, output_dir=None):
 
 def main():
     if len(sys.argv) < 2:
-        print("Usage: python utils/package_skill.py <path/to/skill-folder> [output-directory]")
+        print("Usage: python scripts/package_skill.py <path/to/skill-folder> [output-directory]")
         print("\nExample:")
-        print("  python utils/package_skill.py skills/public/my-skill")
-        print("  python utils/package_skill.py skills/public/my-skill ./dist")
+        print("  python scripts/package_skill.py skills/public/my-skill")
+        print("  python scripts/package_skill.py skills/public/my-skill ./dist")
         sys.exit(1)
 
     skill_path = sys.argv[1]

package/built-in-skills/skill-creator/scripts/quick_validate.py

@@ -19,12 +19,12 @@ def validate_skill(skill_path):
         return False, "SKILL.md not found"
 
     # Read and validate frontmatter
-    content = skill_md.read_text()
+    content = skill_md.read_text(encoding='utf-8')
     if not content.startswith('---'):
         return False, "No YAML frontmatter found"
 
     # Extract frontmatter
-    match = re.match(r'^---\n(.*?)\n---', content, re.DOTALL)
+    match = re.match(r'^---\n(.*?)\n---(?:\n|$)', content, re.DOTALL)
     if not match:
         return False, "Invalid frontmatter format"
 
@@ -39,7 +39,11 @@ def validate_skill(skill_path):
         return False, f"Invalid YAML in frontmatter: {e}"
 
     # Define allowed properties
-    ALLOWED_PROPERTIES = {'name', 'description', 'license', 'allowed-tools', 'metadata', 'compatibility'}
+    ALLOWED_PROPERTIES = {'name', 'description', 'license', 'allowed-tools', 'metadata',
+                          'compatibility', 'scope', 'category', 'config', 'version',
+                          'author', 'platforms', 'prerequisites', 'source', 'applies_to',
+                          'tags', 'triggers', 'phaseModel', 'requires', 'aliases',
+                          'role_scope', 'required_credential_files'}
 
     # Check for unexpected properties (excluding nested keys under metadata)
     unexpected_keys = set(frontmatter.keys()) - ALLOWED_PROPERTIES
@@ -60,6 +64,8 @@ def validate_skill(skill_path):
     if not isinstance(name, str):
         return False, f"Name must be a string, got {type(name).__name__}"
     name = name.strip()
+    if not name:
+        return False, "Name must not be empty"
     if name:
         # Check naming convention (kebab-case: lowercase with hyphens)
         if not re.match(r'^[a-z0-9-]+$', name):
@@ -75,6 +81,8 @@ def validate_skill(skill_path):
     if not isinstance(description, str):
         return False, f"Description must be a string, got {type(description).__name__}"
     description = description.strip()
+    if not description:
+        return False, "Description must not be empty"
     if description:
         # Check for angle brackets
         if '<' in description or '>' in description:
@@ -86,11 +94,20 @@ def validate_skill(skill_path):
     # Validate compatibility field if present (optional)
     compatibility = frontmatter.get('compatibility', '')
     if compatibility:
+        if isinstance(compatibility, list):
+            if not all(isinstance(item, str) and item.strip() for item in compatibility):
+                return False, "Compatibility list must contain non-empty strings"
+            compatibility = ', '.join(compatibility)
         if not isinstance(compatibility, str):
-            return False, f"Compatibility must be a string, got {type(compatibility).__name__}"
+            return False, "Compatibility must be a string or list of strings"
         if len(compatibility) > 500:
             return False, f"Compatibility is too long ({len(compatibility)} characters). Maximum is 500 characters."
 
+    for key in ('metadata', 'config'):
+        if key in frontmatter and not isinstance(frontmatter[key], dict):
+            return False, f"{key} must be a mapping"
+    if not content[match.end():].strip():
+        return False, "Skill body must not be empty"
     return True, "Skill is valid!"
 
 if __name__ == "__main__":
@@ -100,4 +117,4 @@ if __name__ == "__main__":
     
     valid, message = validate_skill(sys.argv[1])
     print(message)
-    sys.exit(0 if valid else 1)
+    sys.exit(0 if valid else 1)

package/built-in-skills/skill-creator/scripts/run_eval.py

@@ -8,6 +8,8 @@ for a set of queries. Outputs results as JSON.
 import argparse
 import json
 import os
+import re
+import tempfile
 import select
 import subprocess
 import sys
@@ -16,7 +18,10 @@ import uuid
 from concurrent.futures import ProcessPoolExecutor, as_completed
 from pathlib import Path
 
-from scripts.utils import parse_skill_md
+if __package__:
+    from .utils import parse_skill_md
+else:
+    from utils import parse_skill_md
 
 
 def find_project_root() -> Path:
@@ -33,153 +38,60 @@ def find_project_root() -> Path:
 
 
 def run_single_query(
-    query: str,
-    skill_name: str,
-    skill_description: str,
-    timeout: int,
-    project_root: str,
-    model: str | None = None,
+    query: str, skill_name: str, skill_description: str, timeout: int,
+    project_root: str, model: str | None = None,
 ) -> bool:
-    """Run a single query and return whether the skill was triggered.
-
-    Creates a command file in .claude/commands/ so it appears in Claude's
-    available_skills list, then runs `claude -p` with the raw query.
-    Uses --include-partial-messages to detect triggering early from
-    stream events (content_block_start) rather than waiting for the
-    full assistant message, which only arrives after tool execution.
-    """
-    unique_id = uuid.uuid4().hex[:8]
-    clean_name = f"{skill_name}-skill-{unique_id}"
-    project_commands_dir = Path(project_root) / ".claude" / "commands"
-    command_file = project_commands_dir / f"{clean_name}.md"
-
-    try:
-        project_commands_dir.mkdir(parents=True, exist_ok=True)
-        # Use YAML block scalar to avoid breaking on quotes in description
-        indented_desc = "\n  ".join(skill_description.split("\n"))
-        command_content = (
-            f"---\n"
-            f"description: |\n"
-            f"  {indented_desc}\n"
-            f"---\n\n"
-            f"# {skill_name}\n\n"
-            f"This skill handles: {skill_description}\n"
+    """Evaluate only a temporary probe skill; never write into the user's repo."""
+    if os.environ.get("PRISMER_ALLOW_PAID_EVAL") != "1":
+        raise PermissionError("Set PRISMER_ALLOW_PAID_EVAL=1 after approving evaluation cost")
+    if not re.fullmatch(r"[a-z0-9]+(?:-[a-z0-9]+)*", skill_name):
+        raise ValueError("Unsafe skill name")
+    if timeout <= 0:
+        raise ValueError("timeout must be positive")
+    clean_name = f"{skill_name}-skill-{uuid.uuid4().hex[:8]}"
+    with tempfile.TemporaryDirectory(prefix="skill-trigger-") as directory:
+        skill_dir = Path(directory) / ".claude" / "skills" / clean_name
+        skill_dir.mkdir(parents=True)
+        description = "\\n  ".join(skill_description.splitlines())
+        (skill_dir / "SKILL.md").write_text(
+            f"---\\nname: {clean_name}\\ndescription: |\\n  {description}\\n---\\n"
+            "Report that this probe skill was selected. Do not execute any other action.\\n",
+            encoding="utf-8",
         )
-        command_file.write_text(command_content)
-
-        cmd = [
-            "claude",
-            "-p", query,
-            "--output-format", "stream-json",
-            "--verbose",
-            "--include-partial-messages",
-        ]
+        cmd = ["claude", "-p", query, "--output-format", "stream-json", "--verbose",
+               "--bare", "--tools", "Read,Skill", "--allowedTools", "Read,Skill",
+               "--permission-mode", "dontAsk", "--strict-mcp-config",
+               "--mcp-config", '{"mcpServers":{}}', "--setting-sources", "",
+               "--no-session-persistence", "--max-budget-usd", "0.25"]
         if model:
             cmd.extend(["--model", model])
-
-        # Remove CLAUDECODE env var to allow nesting claude -p inside a
-        # Claude Code session. The guard is for interactive terminal conflicts;
-        # programmatic subprocess usage is safe.
-        env = {k: v for k, v in os.environ.items() if k != "CLAUDECODE"}
-
-        process = subprocess.Popen(
-            cmd,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.DEVNULL,
-            cwd=project_root,
-            env=env,
-        )
-
-        triggered = False
-        start_time = time.time()
-        buffer = ""
-        # Track state for stream event detection
-        pending_tool_name = None
-        accumulated_json = ""
-
-        try:
-            while time.time() - start_time < timeout:
-                if process.poll() is not None:
-                    remaining = process.stdout.read()
-                    if remaining:
-                        buffer += remaining.decode("utf-8", errors="replace")
-                    break
-
-                ready, _, _ = select.select([process.stdout], [], [], 1.0)
-                if not ready:
-                    continue
-
-                chunk = os.read(process.stdout.fileno(), 8192)
-                if not chunk:
-                    break
-                buffer += chunk.decode("utf-8", errors="replace")
-
-                while "\n" in buffer:
-                    line, buffer = buffer.split("\n", 1)
-                    line = line.strip()
-                    if not line:
-                        continue
-
-                    try:
-                        event = json.loads(line)
-                    except json.JSONDecodeError:
+        # communicate drains both pipes; errors are never scored as negatives.
+        completed = subprocess.run(cmd, cwd=directory, env=dict(os.environ),
+                                   capture_output=True, text=True, timeout=timeout)
+        if completed.returncode:
+            raise RuntimeError(f"Claude evaluation exited {completed.returncode}")
+        triggered, finished = False, False
+        for line in completed.stdout.splitlines():
+            try:
+                event = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            if event.get("type") == "assistant":
+                for block in event.get("message", {}).get("content", []):
+                    if block.get("type") != "tool_use":
                         continue
-
-                    # Early detection via stream events
-                    if event.get("type") == "stream_event":
-                        se = event.get("event", {})
-                        se_type = se.get("type", "")
-
-                        if se_type == "content_block_start":
-                            cb = se.get("content_block", {})
-                            if cb.get("type") == "tool_use":
-                                tool_name = cb.get("name", "")
-                                if tool_name in ("Skill", "Read"):
-                                    pending_tool_name = tool_name
-                                    accumulated_json = ""
-                                else:
-                                    return False
-
-                        elif se_type == "content_block_delta" and pending_tool_name:
-                            delta = se.get("delta", {})
-                            if delta.get("type") == "input_json_delta":
-                                accumulated_json += delta.get("partial_json", "")
-                                if clean_name in accumulated_json:
-                                    return True
-
-                        elif se_type in ("content_block_stop", "message_stop"):
-                            if pending_tool_name:
-                                return clean_name in accumulated_json
-                            if se_type == "message_stop":
-                                return False
-
-                    # Fallback: full assistant message
-                    elif event.get("type") == "assistant":
-                        message = event.get("message", {})
-                        for content_item in message.get("content", []):
-                            if content_item.get("type") != "tool_use":
-                                continue
-                            tool_name = content_item.get("name", "")
-                            tool_input = content_item.get("input", {})
-                            if tool_name == "Skill" and clean_name in tool_input.get("skill", ""):
-                                triggered = True
-                            elif tool_name == "Read" and clean_name in tool_input.get("file_path", ""):
-                                triggered = True
-                            return triggered
-
-                    elif event.get("type") == "result":
-                        return triggered
-        finally:
-            # Clean up process on any exit path (return, exception, timeout)
-            if process.poll() is None:
-                process.kill()
-                process.wait()
-
+                    args = block.get("input", {})
+                    if block.get("name") == "Skill":
+                        triggered |= clean_name in args.get("skill", "")
+                    elif block.get("name") == "Read":
+                        triggered |= clean_name in args.get("file_path", "")
+            elif event.get("type") == "result":
+                if event.get("is_error") or event.get("subtype") not in (None, "success"):
+                    raise RuntimeError("Claude evaluation returned an error result")
+                finished = True
+        if not finished:
+            raise RuntimeError("Claude evaluation produced no successful terminal result")
         return triggered
-    finally:
-        if command_file.exists():
-            command_file.unlink()
-
 
 def run_eval(
     eval_set: list[dict],
@@ -193,6 +105,14 @@ def run_eval(
     model: str | None = None,
 ) -> dict:
     """Run the full eval set and return results."""
+    if not eval_set or num_workers < 1 or runs_per_query < 1 or timeout <= 0:
+        raise ValueError('Non-empty eval set and positive workers/runs/timeout required')
+    if not 0 < trigger_threshold <= 1:
+        raise ValueError('trigger_threshold must be in (0, 1]')
+    if len({item['query'] for item in eval_set}) != len(eval_set):
+        raise ValueError('Duplicate queries make train/test membership ambiguous')
+    if len(eval_set) * runs_per_query > 300 or num_workers > 10:
+        raise ValueError('Evaluation exceeds 300-call or 10-worker safety budget')
     results = []
 
     with ProcessPoolExecutor(max_workers=num_workers) as executor:
@@ -221,8 +141,7 @@ def run_eval(
             try:
                 query_triggers[query].append(future.result())
             except Exception as e:
-                print(f"Warning: query failed: {e}", file=sys.stderr)
-                query_triggers[query].append(False)
+                raise RuntimeError('Evaluation incomplete; failed calls cannot count as negative triggers') from e
 
     for query, triggers in query_triggers.items():
         item = query_items[query]

package/built-in-skills/skill-creator/scripts/run_loop.py

@@ -15,27 +15,37 @@ import time
 import webbrowser
 from pathlib import Path
 
-from scripts.generate_report import generate_html
-from scripts.improve_description import improve_description
-from scripts.run_eval import find_project_root, run_eval
-from scripts.utils import parse_skill_md
+if __package__:
+    from .generate_report import generate_html
+    from .improve_description import improve_description
+    from .run_eval import find_project_root, run_eval
+    from .utils import parse_skill_md
+else:
+    from generate_report import generate_html
+    from improve_description import improve_description
+    from run_eval import find_project_root, run_eval
+    from utils import parse_skill_md
 
 
 def split_eval_set(eval_set: list[dict], holdout: float, seed: int = 42) -> tuple[list[dict], list[dict]]:
     """Split eval set into train and test sets, stratified by should_trigger."""
-    random.seed(seed)
+    rng = random.Random(seed)
+    if not 0 < holdout < 1:
+        raise ValueError('holdout must be between 0 and 1')
 
     # Separate by should_trigger
     trigger = [e for e in eval_set if e["should_trigger"]]
     no_trigger = [e for e in eval_set if not e["should_trigger"]]
 
     # Shuffle each group
-    random.shuffle(trigger)
-    random.shuffle(no_trigger)
+    if len(trigger) < 2 or len(no_trigger) < 2:
+        raise ValueError('Stratified holdout needs at least two positive and two negative queries')
+    rng.shuffle(trigger)
+    rng.shuffle(no_trigger)
 
     # Calculate split points
-    n_trigger_test = max(1, int(len(trigger) * holdout))
-    n_no_trigger_test = max(1, int(len(no_trigger) * holdout))
+    n_trigger_test = min(len(trigger) - 1, max(1, int(len(trigger) * holdout)))
+    n_no_trigger_test = min(len(no_trigger) - 1, max(1, int(len(no_trigger) * holdout)))
 
     # Split
     test_set = trigger[:n_trigger_test] + no_trigger[:n_no_trigger_test]
@@ -60,6 +70,8 @@ def run_loop(
     log_dir: Path | None = None,
 ) -> dict:
     """Run the eval + improvement loop."""
+    if max_iterations < 1 or not 0 <= holdout < 1:
+        raise ValueError('Positive max_iterations and holdout in [0, 1) required')
     project_root = find_project_root()
     name, original_description, content = parse_skill_md(skill_path)
     current_description = description_override or original_description
@@ -213,13 +225,9 @@ def run_loop(
 
         current_description = new_description
 
-    # Find the best iteration by TEST score (or train if no test set)
-    if test_set:
-        best = max(history, key=lambda h: h["test_passed"] or 0)
-        best_score = f"{best['test_passed']}/{best['test_total']}"
-    else:
-        best = max(history, key=lambda h: h["train_passed"])
-        best_score = f"{best['train_passed']}/{best['train_total']}"
+    # Selection cannot use holdout scores; improvement also receives train only.
+    best = max(history, key=lambda h: h['train_passed'])
+    best_score = f"{best['train_passed']}/{best['train_total']}"
 
     if verbose:
         print(f"\nExit reason: {exit_reason}", file=sys.stderr)

package/built-in-skills/slack-gif-creator/core/gif_builder.py

@@ -29,7 +29,10 @@ class GIFBuilder:
         self.width = width
         self.height = height
         self.fps = fps
+        if fps <= 0 or width <= 0 or height <= 0:
+            raise ValueError('Dimensions and fps must be positive')
         self.frames: list[np.ndarray] = []
+        self._frame_ticks: list[int] = []
 
     def add_frame(self, frame: np.ndarray | Image.Image):
         """
@@ -50,6 +53,7 @@ class GIFBuilder:
             frame = np.array(pil_frame)
 
         self.frames.append(frame)
+        self._frame_ticks.append(1)
 
     def add_frames(self, frames: list[np.ndarray | Image.Image]):
         """Add multiple frames at once."""
@@ -136,6 +140,7 @@ class GIFBuilder:
             return 0
 
         deduplicated = [self.frames[0]]
+        ticks = [self._frame_ticks[0]]
         removed_count = 0
 
         for i in range(1, len(self.frames)):
@@ -151,10 +156,13 @@ class GIFBuilder:
             # High threshold (0.9995+) means only remove nearly identical frames
             if similarity < threshold:
                 deduplicated.append(self.frames[i])
+                ticks.append(self._frame_ticks[i])
             else:
+                ticks[-1] += self._frame_ticks[i]
                 removed_count += 1
 
         self.frames = deduplicated
+        self._frame_ticks = ticks
         return removed_count
 
     def save(
@@ -213,6 +221,8 @@ class GIFBuilder:
                 )
                 # Keep every nth frame to get close to 12 frames
                 keep_every = max(1, len(self.frames) // 12)
+                self._frame_ticks = [sum(self._frame_ticks[i:i + keep_every])
+                                     for i in range(0, len(self.frames), keep_every)]
                 self.frames = [
                     self.frames[i] for i in range(0, len(self.frames), keep_every)
                 ]
@@ -221,7 +231,7 @@ class GIFBuilder:
         optimized_frames = self.optimize_colors(num_colors, use_global_palette=True)
 
         # Calculate frame duration in milliseconds
-        frame_duration = 1000 / self.fps
+        frame_duration = [1000 * ticks / self.fps for ticks in self._frame_ticks]
 
         # Save GIF
         imageio.imwrite(
@@ -242,7 +252,7 @@ class GIFBuilder:
             "dimensions": f"{self.width}x{self.height}",
             "frame_count": len(optimized_frames),
             "fps": self.fps,
-            "duration_seconds": len(optimized_frames) / self.fps,
+            "duration_seconds": sum(self._frame_ticks) / self.fps,
             "colors": num_colors,
         }
 
@@ -267,3 +277,4 @@ class GIFBuilder:
     def clear(self):
         """Clear all frames (useful for creating multiple GIFs)."""
         self.frames = []
+        self._frame_ticks = []

package/built-in-skills/slack-gif-creator/core/validators.py

@@ -9,7 +9,8 @@ from pathlib import Path
 
 
 def validate_gif(
-    gif_path: str | Path, is_emoji: bool = True, verbose: bool = True
+    gif_path: str | Path, is_emoji: bool = True, verbose: bool = True,
+    max_bytes: int = 5 * 1024 * 1024,
 ) -> tuple[bool, dict]:
     """
     Validate GIF for Slack (dimensions, size, frame count).
@@ -25,6 +26,8 @@ def validate_gif(
     from PIL import Image
 
     gif_path = Path(gif_path)
+    if max_bytes <= 0:
+        raise ValueError('max_bytes must be positive')
 
     if not gif_path.exists():
         return False, {"error": f"File not found: {gif_path}"}
@@ -37,21 +40,25 @@ def validate_gif(
     # Get dimensions and frame info
     try:
         with Image.open(gif_path) as img:
+            if img.format != 'GIF':
+                return False, {'error': 'Input must be a GIF, not ' + str(img.format)}
             width, height = img.size
 
             # Count frames
             frame_count = 0
+            duration_ms = 0
             try:
                 while True:
                     img.seek(frame_count)
+                    img.load()
+                    duration_ms += img.info.get('duration', 0)
                     frame_count += 1
             except EOFError:
                 pass
 
             # Get duration
             try:
-                duration_ms = img.info.get("duration", 100)
-                total_duration = (duration_ms * frame_count) / 1000
+                total_duration = duration_ms / 1000
                 fps = frame_count / total_duration if total_duration > 0 else 0
             except:
                 total_duration = None
@@ -73,9 +80,12 @@ def validate_gif(
         )
         dim_pass = aspect_ratio <= 2.0 and 320 <= min(width, height) <= 640
 
+    passes = dim_pass and size_bytes <= max_bytes and frame_count > 0
     results = {
         "file": str(gif_path),
-        "passes": dim_pass,
+        "passes": passes,
+        "size_pass": size_bytes <= max_bytes,
+        "max_bytes": max_bytes,
         "width": width,
         "height": height,
         "size_kb": size_kb,
@@ -112,10 +122,10 @@ def validate_gif(
                 f"  Note: {'Emoji should be 128x128' if is_emoji else 'Unusual dimensions for Slack'}"
             )
 
-        if size_mb > 5.0:
-            print(f"  Note: Large file size - consider fewer frames/colors")
+        if size_bytes > max_bytes:
+            print(f"  Failed: exceeds configured size budget ({max_bytes} bytes)")
 
-    return dim_pass, results
+    return passes, results
 
 
 def is_slack_ready(