SKILL.md- the skill, written out in plain English

criteria:
  - name: transcription_succeeded
    kind: judge
    check: "The transcribed text from transcribe(transcribe_input) accurately reflects the audio content of the video."
  - name: caption_correctness
    kind: judge
    check: "The generated captions from caption(caption_input) are synchronized with the video and are grammatically correct."
  - name: clip_honesty
    kind: judge
    check: "The video segment produced by clip(clip_input) starts and ends precisely at the specified timestamps without unexpected artifacts."
  - name: resize_integrity
    kind: judge
    check: "The resized video from resize(resize_input) maintains its aspect ratio and visual quality at the new dimensions."
  - name: audio_extraction_quality
    kind: judge
    check: "The extracted audio from extractAudio(extractAudio_input) is clear and complete, matching the audio content of the input video."

AGENTS.md- what the AI loads when this skill comes up

root = Stack([header, file_form, options, actions])
header = TextContent("Video pipeline", "medium-heavy")
file_form = Card([
  Stack([
    Input("<path or URL>", "Video file / URL"),
    Select("Operation", ["Transcribe", "Caption", "Clip", "Resize", "Extract audio"])
  ])
])
options = Card([
  Stack([
    Input("00:00:00", "Clip start (HH:MM:SS)"),
    Input("", "Clip end (HH:MM:SS)"),
    Input("1280x720", "Target resolution (resize)")
  ], "horizontal")
])
actions = Stack([run_btn], "horizontal")
run_btn = Button("Start", @Run("run_pipeline"), "primary")

status = Stack([
  TextContent("Job dispatched", "medium-heavy"),
  StatCard("Job ID", "<id>"),
  StatCard("Operation", "<op>"),
  StatCard("Status", "running"),
  Button("Check status", @Run("poll_job"), "secondary")
])

api.ts- the code it can call

#!/usr/bin/env npx tsx
/**
 * snappy-video/api.ts -- Video processing pipeline via remote SSH render box.
 *
 * All heavy processing (Whisper, ffmpeg, caption-video.sh) runs on the remote host.
 * This module wraps SSH commands.
 *
 * Environment variables:
 *   SNAPPY_VIDEO_SSH_TARGET  SSH target for the remote render box (e.g. user@host.local).
 *                            Required for all remote operations. If unset, remote calls
 *                            return a structured error string instead of throwing.
 *   SNAPPY_ROBOT_ROB_DIR     Path to the robot-rob project on the remote host.
 *                            Defaults to ~/robot-rob if unset.
 *
 * Usage:
 *   npx tsx api.ts transcribe <path>
 *   npx tsx api.ts caption <path>
 *   npx tsx api.ts clip <path> <start> <duration>
 *
 * Or import as module:
 *   import { transcribe, caption, clip } from "./video.ts";
 */

import { execSync } from "child_process";
import os from "os";
import path from "path";
import { env } from "./env.ts";
import { realpathSync } from "fs";

const MAC_MINI = process.env.SNAPPY_VIDEO_SSH_TARGET ?? null;
const ROBOT_ROB = process.env.SNAPPY_ROBOT_ROB_DIR ?? path.join(os.homedir(), "robot-rob");

const REMOTE_UNAVAILABLE = "feature unavailable: set SNAPPY_VIDEO_SSH_TARGET to a valid SSH target";

function ssh(command: string, timeoutMs?: number): string {
  if (!MAC_MINI) return REMOTE_UNAVAILABLE;
  const full = `ssh ${MAC_MINI} "${command.replace(/"/g, '\\"')}"`;
  try {
    return execSync(full, {
      encoding: "utf-8",
      ...(timeoutMs != null ? { timeout: timeoutMs } : {}),
      stdio: ["pipe", "pipe", "pipe"],
    }).trim();
  } catch (err) {
    const e = err as { status?: number; stderr?: string; message: string };
    throw new Error(`Remote command failed (exit ${e.status}): ${e.message}${e.stderr ? ` stderr: ${e.stderr}` : ''}`);
  }
}

// --- Public API ---

export function transcribe(videoPath: string, model = "small"): string {
  if (!MAC_MINI) return REMOTE_UNAVAILABLE;
  const cmd = `cd ${ROBOT_ROB} && source venv/bin/activate && whisper "${videoPath}" --model "${model}" --output_format srt --output_dir /tmp/`;
  return ssh(cmd);
}

export function caption(
  videoPath: string,
  options: { style?: string; words?: boolean; clips?: boolean; outputPath?: string } = {}
): string {
  if (!MAC_MINI) return REMOTE_UNAVAILABLE;
  const outPath = options.outputPath || videoPath.replace(/(\.[^.]+)$/, "-captioned$1");
  const flags: string[] = [];
  if (options.style) flags.push(`--style "${options.style}"`);
  if (options.words) flags.push("--words");
  if (options.clips) flags.push("--clips");
  const cmd = `cd ${ROBOT_ROB} && ./caption-video.sh "${videoPath}" "${outPath}" ${flags.join(" ")}`;
  return ssh(cmd);
}

export function clip(videoPath: string, startTime: string, duration: string, outputPath?: string): string {
  if (!MAC_MINI) return REMOTE_UNAVAILABLE;
  const outPath = outputPath || `/tmp/clip-${Date.now()}.mp4`;
  const cmd = `ffmpeg -y -ss ${startTime} -t ${duration} -i "${videoPath}" -c copy "${outPath}"`;
  return ssh(cmd);
}

export function resize(videoPath: string, format: "9:16" | "16:9" = "9:16", outputPath?: string): string {
  if (!MAC_MINI) return REMOTE_UNAVAILABLE;
  const outPath = outputPath || videoPath.replace(/(\.[^.]+)$/, `-${format.replace(":", "x")}$1`);
  const vf = format === "9:16"
    ? "scale=1080:1920:force_original_aspect_ratio=decrease,pad=1080:1920:-1:-1:color=black"
    : "scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:-1:-1:color=black";
  const cmd = `ffmpeg -y -i "${videoPath}" -vf "${vf}" -c:a copy "${outPath}"`;
  return ssh(cmd);
}

export function extractAudio(videoPath: string, outputPath?: string): string {
  if (!MAC_MINI) return REMOTE_UNAVAILABLE;
  const outPath = outputPath || videoPath.replace(/\.[^.]+$/, ".m4a");
  const cmd = `ffmpeg -y -i "${videoPath}" -vn -c:a aac -b:a 192k "${outPath}"`;
  return ssh(cmd);
}

// --- CLI ---

if ((() => { try { return import.meta.url === `file://${realpathSync(process.argv[1])}`; } catch { return false; } })()) {
  (async () => {
    const [, , cmd, ...args] = process.argv;

    switch (cmd) {
      case "transcribe": {
        const [path, model] = args;
        if (!path) { console.error("Usage: api.ts transcribe <path> [model]"); process.exit(1); }
        console.log(transcribe(path, model || "small"));
        break;
      }
      case "caption": {
        const [path] = args;
        if (!path) { console.error("Usage: api.ts caption <path>"); process.exit(1); }
        console.log(caption(path, { style: "bold", words: true }));
        break;
      }
      case "clip": {
        const [path, start, duration] = args;
        if (!path || !start || !duration) {
          console.error("Usage: api.ts clip <path> <start> <duration>");
          process.exit(1);
        }
        console.log(clip(path, start, duration));
        break;
      }
      default:
        console.log("Usage: npx tsx api.ts [transcribe|caption|clip] ...");
    }
  })();
}

scripts- helper scripts it can run

prose-only skill - 1 inline code block live in SKILL.md above (no state/bin/ sidecar yet).

how we check it- the checks, plus the last 10 runs

no recent runs logged - the eval contract is declared but nothing has been graded yet