Fix skipped videos without a runtime limit; calibrate video pricing

README.md

@@ -121,17 +121,21 @@ a first-person human demonstration, following LeRobot's `--human_video` annotati
 Both media models run on fal through HF Inference Providers with the signed-in user's
 token. Selecting videos also selects Subtasks, since there is one video per subtask.
 
-The estimate follows the selected episodes' lengths: it expects about one subtask per 5 s of
-each episode (at least one per episode), allows twice that in the upper bound, and applies the
-per-episode cap. **Parallel generations** (1–32, default 8) limits simultaneous media
-requests across the whole job. The review warns when the expected videos at that parallelism
-would outlast the job timeout (about 3 min per video).
-
-Videos start only after an episode's
-annotations pass validation, and each request reserves its quoted price
-(`model_catalog.HUMAN_VIDEO`) from the spending target first. A failed video is recorded
-and the others continue. Reaching the target or the runtime limit stops further videos but
-keeps the episode's annotations. The launch checks that both fal mappings are live.
+The estimate uses the selected episodes' total seconds and count, calibrated on the first
+video run (3 ReBot episodes, 159.7 s, 33 subtasks): **1 subtask per episode + 1 per 5.3 s**,
+up to 1.5× that in the upper bound, with the per-episode cap applied. Each video is priced at
+fal's list prices: the edit at $0.03 per output megapixel (1024×1024) and the 5 s 480p video
+at $0.05/s, about $0.28 in total, plus about 1,750 input and 550 output VLM tokens.
+**Parallel generations** (1–32, default 8) limits simultaneous media requests across the
+whole job. The review warns when the expected videos at that parallelism would outlast the
+job timeout (about 3 min per video).
+
+Videos start only after an episode's annotations pass validation. Each request holds a
+conservative reservation (`model_catalog.HUMAN_VIDEO`) from the spending target while in
+flight and is reconciled to its list price when it returns. A failed video is recorded and
+the others continue. Videos stop at the spending target, or before the runtime limit (the job
+timeout when none is set), without paying for an edit whose video could not finish; the
+episode's annotations are kept. The launch checks that both fal mappings are live.
 
 The output holds `annotation_studio/human_videos/episode_XXXXXX/segment_XXX{.mp4,
 _first_frame.png,_robot_frame.png}` (named by source episode) and `index.json`, which lists

frontend/src/main.tsx

@@ -94,13 +94,15 @@ type HumanVideoProfile = {
   video_model: string;
   resolution: string;
   duration_s: number;
-  edit_usd: number;
-  video_usd: number;
+  segment_usd: number;
+  edit_usd_per_megapixel: number;
+  video_usd_per_second: number;
   checked_at: string;
   pricing_url: string;
   segment_choices: number[];
   parallel_choices: number[];
   seconds_per_subtask: number;
+  subtasks_per_episode: number;
   minutes_per_video: number;
 };
 type ModelCatalog = {
@@ -1129,14 +1131,14 @@ function App() {
                       {modelCatalog.human_video.resolution} via{" "}
                       {modelCatalog.human_video.provider_name} on Inference
                       Providers · about{" "}
-                      {money(
-                        modelCatalog.human_video.edit_usd +
-                          modelCatalog.human_video.video_usd,
-                      )}{" "}
-                      per video, billed to your account. The estimate counts
-                      about one subtask per{" "}
-                      {modelCatalog.human_video.seconds_per_subtask} s of each
-                      episode.
+                      {money(modelCatalog.human_video.segment_usd)} per video
+                      (edit ${modelCatalog.human_video.edit_usd_per_megapixel}
+                      /MP + video $
+                      {modelCatalog.human_video.video_usd_per_second}/s), billed
+                      to your account. The estimate counts{" "}
+                      {modelCatalog.human_video.subtasks_per_episode} + one
+                      subtask per {modelCatalog.human_video.seconds_per_subtask}{" "}
+                      s of each episode.
                       {options.features.includes(HUMAN_VIDEOS) &&
                         " One video per subtask, so Subtasks are included."}{" "}
                       <a

human_video.py

@@ -52,20 +52,32 @@ def subtask_spans(record, staging):
 
 
 class FalMedia:
-    """Qwen-Image-Edit + MiniMax-H3 on fal through the HF router, charged to ``budget``."""
+    """Qwen-Image-Edit + MiniMax-H3 on fal through the HF router, charged to ``budget``.
 
-    def __init__(self, token, budget, remaining_time, profile=None, concurrency=None, poll_interval=2.0):
-        self.token, self.budget, self.remaining_time = token, budget, remaining_time
-        self.profile = profile or human_video_profile()
+    ``deadline`` is the epoch by which the job must finish (None = no limit).
+    """
+
+    def __init__(self, token, budget, deadline=None, profile=None, concurrency=None, poll_interval=2.0):
+        self.token, self.budget, self.deadline = token, budget, deadline
+        # Pinned manifests may predate newer price fields; fill them from the current catalog.
+        self.profile = {**human_video_profile(), **(profile or {})}
         self.poll_interval = poll_interval
         # Job-wide limit on simultaneous media requests, shared by every episode thread.
         self.concurrency = max(1, min(int(concurrency or self.profile["concurrency"]), 32))
         self.semaphore = threading.BoundedSemaphore(self.concurrency)
 
+    def time_left(self):
+        return self.deadline - time.time() if self.deadline else float("inf")
+
+    def check_time(self):
+        """Raise before paying for a segment that could not finish before the deadline."""
+        if self.time_left() < VIDEO_SECONDS_NEEDED:
+            raise DeadlineExceededError("Not enough runtime left for another video.")
+
     def edit_image(self, image, prompt):
         from huggingface_hub import InferenceClient
 
-        self.remaining_time()
+        self.check_time()
         with self.semaphore:
             reservation = self.budget.reserve_media(self.profile["edit_usd"])
             client = InferenceClient(provider=self.profile["provider"], api_key=self.token)
@@ -75,7 +87,8 @@ class FalMedia:
                 model=self.profile["edit_model"],
                 guidance_scale=self.profile["edit_guidance_scale"],
             )
-            self.budget.record_media(reservation)
+            megapixels = edited.width * edited.height / 1e6
+            self.budget.record_media(reservation, megapixels * self.profile["edit_usd_per_megapixel"])
         # fal returns a square image; keep the camera's size and aspect ratio.
         return edited.convert("RGB").resize(image.size, Image.LANCZOS)
 
@@ -83,8 +96,7 @@ class FalMedia:
         from huggingface_hub.inference._providers.fal_ai import FalAIImageToVideoTask
         from huggingface_hub.utils import get_session, hf_raise_for_status
 
-        if self.remaining_time() < VIDEO_SECONDS_NEEDED:
-            raise DeadlineExceededError("Not enough runtime left for another video.")
+        self.check_time()
         # InferenceClient has no image-text-to-video method yet; fal's image-to-video helper speaks
         # the same queue protocol once its task matches the model's mapping.
         helper = FalAIImageToVideoTask()
@@ -119,7 +131,8 @@ class FalMedia:
             while status != "COMPLETED":
                 if status in ("FAILED", "ERROR", "CANCELLED"):
                     raise RuntimeError(f"The video provider reported {status}.")
-                self.remaining_time()
+                if self.time_left() <= 5:
+                    raise DeadlineExceededError("Runtime limit reached while a video was generating.")
                 time.sleep(self.poll_interval)
                 polled = session.get(f"{base}{path}/status{query}", headers=request.headers, timeout=30)
                 hf_raise_for_status(polled)
@@ -130,7 +143,9 @@ class FalMedia:
             # The result is a public CDN link; the token is never sent there.
             video = session.get(url, timeout=120)
             hf_raise_for_status(video)
-            self.budget.record_media(reservation)
+            self.budget.record_media(
+                reservation, self.profile["video_usd_per_second"] * self.profile["duration_s"]
+            )
         return video.content
 
 
@@ -199,6 +214,7 @@ def generate_human_videos(record, staging, vlm, frames, full_frames, media, out_
             entry["status"] = "skipped"
             return entry
         try:
+            media.check_time()
             if not isinstance(plan, dict) or not plan.get("edit_prompt"):
                 raise ValueError("The model returned no human-video plan.")
             robot = full_frames.frames_at(record, [_nearest(ts, span["start"])])[0].convert("RGB")
@@ -230,7 +246,8 @@ def generate_human_videos(record, staging, vlm, frames, full_frames, media, out_
             stop.set()
             entry["status"] = "time_stopped" if isinstance(exc, DeadlineExceededError) else "budget_stopped"
         except Exception as exc:
-            entry.update(status="failed", error_type=type(exc).__name__)
+            # A short reason for index.json; provider errors carry no credentials.
+            entry.update(status="failed", error_type=type(exc).__name__, error=str(exc)[:300])
         return entry
 
     with ThreadPoolExecutor(max_workers=min(len(spans), getattr(media, "concurrency", 1))) as pool:

model_catalog.py

@@ -219,15 +219,23 @@ HUMAN_VIDEO = {
     "video_task": "image-text-to-video",
     "resolution": "480P",
     "duration_s": 5,
-    # $0.03 per megapixel; fal returns about 1 MP, reserved as 1.33 MP.
+    # fal list prices. The edit is billed per output megapixel (fal returns 1024x1024), the video
+    # per second of output.
+    "edit_usd_per_megapixel": 0.03,
+    "edit_megapixels": 1.05,
+    "video_usd_per_second": 0.05,
+    # Reserved before each request and reconciled to the price above on success.
     "edit_usd": 0.04,
-    # $0.05 per second at 480p; the clip is 5 s, reserved as 6 s.
     "video_usd": 0.30,
     # Default simultaneous media requests per job (user-selectable up to 32).
     "concurrency": 8,
-    # Estimation only: the action-phase prompt yields about one subtask per 5 s of episode
-    # (the same rate the memory estimate uses), and a video takes up to ~3 min on fal.
-    "seconds_per_subtask": 5,
+    # Estimation only, calibrated on the first Studio video run (3 ReBot episodes, 159.7 s,
+    # 33 subtasks): subtasks ≈ 1 per episode + 1 per 5.3 s. The two VLM calls per video used
+    # about 1,750 input and 550 output tokens together. A video takes up to ~3 min on fal.
+    "subtasks_per_episode": 1,
+    "seconds_per_subtask": 5.3,
+    "vlm_input_tokens": 1750,
+    "vlm_output_tokens": 550,
     "minutes_per_video": 3,
     "checked_at": "2026-09-30",
     "pricing_url": "https://fal.ai/models/minimax/h3/image-to-video",
@@ -248,6 +256,16 @@ def human_video_profile():
 
 
 def human_video_segment_cost(profile=None):
+    """Expected fal charge for one video (edit + animation) at list prices."""
+    profile = profile or HUMAN_VIDEO
+    return (
+        profile["edit_usd_per_megapixel"] * profile["edit_megapixels"]
+        + profile["video_usd_per_second"] * profile["duration_s"]
+    )
+
+
+def human_video_segment_reservation(profile=None):
+    """Conservative amount held from the spending target while one video is in flight."""
     profile = profile or HUMAN_VIDEO
     return profile["edit_usd"] + profile["video_usd"]
 
@@ -261,5 +279,6 @@ def public_models():
             **human_video_profile(),
             "segment_choices": list(HUMAN_VIDEO_SEGMENT_CHOICES),
             "parallel_choices": list(HUMAN_VIDEO_PARALLEL_CHOICES),
+            "segment_usd": human_video_segment_cost(),
         },
     }

provider.py

@@ -65,11 +65,12 @@ class Budget:
             self.media_attempts += 1
         return amount
 
-    def record_media(self, amount):
-        """A media request returned its output; count its quoted price as measured."""
+    def record_media(self, reservation, cost):
+        """A media request returned its output: replace its reservation with its list price."""
         with self.lock:
-            self.measured += amount
-            self.media_usd += amount
+            self.reserved += cost - reservation
+            self.measured += cost
+            self.media_usd += cost
             self.media_completed += 1
 
     def reconcile(self, reservation, usage):

studio.py

@@ -20,6 +20,7 @@ from model_catalog import (
     HUMAN_VIDEO_SEGMENT_CHOICES,
     human_video_profile,
     human_video_segment_cost,
+    human_video_segment_reservation,
     model_profile,
 )
 from prompt_config import TEMPLATES, validate_prompts
@@ -215,20 +216,21 @@ def estimate(
     videos = videos_max = media = media_max = video_minutes = 0
     if HUMAN_VIDEOS in features:
         video_profile = human_video_profile()
-        # One video per subtask, and subtask counts scale with episode length: expect one per
-        # `seconds_per_subtask`, allow twice that in the upper bound, and apply the per-episode cap.
+        # One video per subtask. Subtasks grow with each episode's length (calibrated rate in
+        # model_catalog.HUMAN_VIDEO); the upper bound allows 1.5x that; the per-episode cap applies.
         cap = human_video_segments or math.inf
-        per = video_profile["seconds_per_subtask"]
+        base, per = video_profile["subtasks_per_episode"], video_profile["seconds_per_subtask"]
         fps = selection["info"]["fps"]
-        lengths = [r["length"] / fps for r in selection["episodes"]]
-        videos = sum(min(cap, max(1.0, s / per)) for s in lengths)
-        videos_max = sum(min(cap, max(1, math.ceil(2 * s / per))) for s in lengths)
+        expected = [base + r["length"] / fps / per for r in selection["episodes"]]
+        videos = sum(min(cap, e) for e in expected)
+        videos_max = sum(min(cap, math.ceil(1.5 * e)) for e in expected)
         media = videos * human_video_segment_cost()
         media_max = videos_max * human_video_segment_cost()
         video_minutes = math.ceil(videos / human_video_parallel) * video_profile["minutes_per_video"]
-        # Two VLM calls per video: plan + edit prompt (6 frames), video prompt (edited frame + 6).
-        inputs += videos * (2600 + 3500)
-        outputs += videos * (300 + 350)
+        # Two VLM calls per video: the plan and edit prompt (6 thumbnails), then the video prompt
+        # (edited frame + 6 thumbnails). The plan call runs for every capped subtask.
+        inputs += videos * video_profile["vlm_input_tokens"]
+        outputs += videos * video_profile["vlm_output_tokens"]
         calls += videos * 2
     if "plan_render" in prompts:
         plan_calls = max(n, seconds / 5) + (n * 3 if "Interjections & speech" in features else 0)
@@ -252,12 +254,12 @@ def estimate(
     cpu_max = math.ceil(hours * 60 + 1) * cpu_rate
     # Range includes retries, grounding, variable segment counts and recovery.
     return {
-        "low": inference * 0.6 + media * 0.6 + cpu_max,
+        "low": inference * 0.6 + media * 0.8 + cpu_max,
         "high": inference * 2.5 + media_max + cpu_max,
         "inference": inference,
         "media": media,
         "media_max": media_max,
-        "videos": math.ceil(videos),
+        "videos": round(videos),
         "videos_max": videos_max,
         "video_minutes": video_minutes,
         "video_parallel": human_video_parallel if videos else 0,
@@ -507,7 +509,7 @@ def launch(
         if human_video["profile"] != human_video_profile():
             raise ValueError("Video pricing changed. Calculate a fresh estimate.")
         # One video must fit next to one conservative text reservation.
-        minimum_reservation += human_video_segment_cost()
+        minimum_reservation += human_video_segment_reservation()
     if budget - plan["costs"]["cpu_max"] < minimum_reservation:
         raise ValueError(
             f"This model needs at least ${minimum_reservation + plan['costs']['cpu_max']:.2f} for one conservative request reservation. Increase the target or choose a lower-cost model."

test_human_video.py

@@ -13,7 +13,11 @@ from PIL import Image
 sys.path.insert(0, str(Path(__file__).parent))
 import human_video  # noqa: E402
 import studio  # noqa: E402
-from model_catalog import human_video_profile, human_video_segment_cost  # noqa: E402
+from model_catalog import (  # noqa: E402
+    human_video_profile,
+    human_video_segment_cost,
+    human_video_segment_reservation,
+)
 from provider import Budget, BudgetExceededError, DeadlineExceededError  # noqa: E402
 
 from lerobot.annotations.steerable_pipeline.reader import EpisodeRecord
@@ -64,29 +68,41 @@ def episodes(*seconds, fps=30):
     }
 
 
-def test_video_estimate_scales_with_episode_length_and_count():
+def test_video_estimate_matches_the_calibration_run():
+    # First Studio video run: 3 ReBot episodes (68.6 s, 46.8 s, 44.4 s) had 33 subtasks.
+    run = video_estimate(episodes(68.6, 46.8, 44.4))
+    assert run["videos"] == 33
+    # fal list prices: $0.03/MP for a 1024x1024 edit + $0.05/s for a 5 s 480p video.
+    assert human_video_segment_cost() == pytest.approx(0.03 * 1.05 + 0.05 * 5)
+    assert run["media"] == pytest.approx(run["videos"] * human_video_segment_cost(), rel=0.03)
+    assert human_video_segment_reservation() > human_video_segment_cost()
+
+
+def test_video_estimate_scales_with_total_seconds_and_episode_count():
     base = studio.estimate(selection(), ["Subtasks"], 0.1, 4, 0.0005)
     assert base["media"] == 0 and base["videos"] == 0
-    # 10 s and 20 s episodes: about one subtask per 5 s -> 2 + 4 videos, up to 4 + 8.
+    # 10 s and 20 s episodes: 1 + s / 5.3 subtasks each -> 7.66 videos, up to 5 + 8.
     every = video_estimate(selection())
-    assert every["videos"] == 6 and every["videos_max"] == 12
-    assert every["media"] == pytest.approx(6 * human_video_segment_cost())
-    assert every["media_max"] == pytest.approx(12 * human_video_segment_cost())
+    expected = (1 + 10 / 5.3) + (1 + 20 / 5.3)
+    assert every["videos"] == 8 and every["videos_max"] == 13
+    assert every["media"] == pytest.approx(expected * human_video_segment_cost())
+    assert every["media_max"] == pytest.approx(13 * human_video_segment_cost())
     assert every["high"] - base["high"] > every["media_max"]
-    assert every["calls"] == base["calls"] + 12
-    # Longer episodes and more episodes cost more; very short episodes still get one video.
+    assert every["calls"] == pytest.approx(base["calls"] + expected * 2, abs=1)
+    # More seconds and more episodes both add videos; every episode gets at least one.
     assert video_estimate(episodes(40, 40))["media"] > every["media"]
-    assert video_estimate(episodes(10, 20, 10, 20))["videos"] == 12
-    assert video_estimate(episodes(1, 2))["videos"] == 2
+    assert video_estimate(episodes(10, 20, 10, 20))["media"] == pytest.approx(2 * every["media"])
+    assert video_estimate(episodes(15, 15, 15))["videos"] > video_estimate(episodes(45))["videos"]
+    assert video_estimate(episodes(1, 2))["videos"] == 3
     # A per-episode cap bounds both the expected and maximum count.
     capped = video_estimate(selection(), segments=3)
-    assert capped["videos"] == 5 and capped["videos_max"] == 6
+    assert capped["videos"] == 6 and capped["videos_max"] == 6
 
 
 def test_parallel_generations_shorten_the_video_time_estimate():
-    long = episodes(*[60] * 20)  # 240 videos expected
+    long = episodes(*[60] * 20)  # 20 * (1 + 60 / 5.3) = 246.4 videos expected
     slow, fast = video_estimate(long, parallel=1), video_estimate(long, parallel=32)
-    assert slow["video_minutes"] == 240 * 3 and fast["video_minutes"] == 8 * 3
+    assert slow["video_minutes"] == 247 * 3 and fast["video_minutes"] == 8 * 3
     assert slow["media"] == fast["media"]
     with pytest.raises(ValueError, match="parallel"):
         video_estimate(selection(), parallel=64)
@@ -179,9 +195,11 @@ def test_launch_refuses_offline_fal_models_or_stale_video_prices():
 def test_media_budget_reserves_before_request_and_stops_at_target():
     budget = Budget(0.5, 0.15, 0.5)
     reservation = budget.reserve_media(0.3)
-    budget.record_media(reservation)
-    assert budget.summary()["media_usd"] == pytest.approx(0.3)
-    assert budget.summary()["measured_inference_usd"] == pytest.approx(0.3)
+    budget.record_media(reservation, 0.25)
+    # Success replaces the reservation with the list price.
+    assert budget.summary()["media_usd"] == pytest.approx(0.25)
+    assert budget.summary()["measured_inference_usd"] == pytest.approx(0.25)
+    assert budget.reserved == pytest.approx(0.25)
     with pytest.raises(BudgetExceededError):
         budget.reserve_media(0.3)
     assert budget.summary()["media_requests"] == 1
@@ -190,11 +208,15 @@ def test_media_budget_reserves_before_request_and_stops_at_target():
 class FakeMedia:
     concurrency = 4
 
-    def __init__(self, fail_first=False, budget_after=None):
+    def __init__(self, fail_first=False, budget_after=None, out_of_time=False):
         self.profile = human_video_profile()
-        self.fail_first, self.budget_after = fail_first, budget_after
+        self.fail_first, self.budget_after, self.out_of_time = fail_first, budget_after, out_of_time
         self.edits, self.videos = [], []
 
+    def check_time(self):
+        if self.out_of_time:
+            raise DeadlineExceededError("Not enough runtime left for another video.")
+
     def edit_image(self, image, prompt):
         self.edits.append((image.size, prompt))
         return image.transpose(Image.FLIP_LEFT_RIGHT)
@@ -313,9 +335,9 @@ def test_parallel_setting_bounds_simultaneous_media_requests():
     import threading
 
     budget = Budget(5, 0.15, 0.5)
-    assert human_video.FalMedia("t", budget, lambda: 3600).concurrency == human_video_profile()["concurrency"]
-    assert human_video.FalMedia("t", budget, lambda: 3600, concurrency=64).concurrency == 32
-    media = human_video.FalMedia("t", budget, lambda: 3600, concurrency=3)
+    assert human_video.FalMedia("t", budget).concurrency == human_video_profile()["concurrency"]
+    assert human_video.FalMedia("t", budget, concurrency=64).concurrency == 32
+    media = human_video.FalMedia("t", budget, concurrency=3)
     active, peak, lock = [0], [0], threading.Lock()
 
     def request():
@@ -415,7 +437,7 @@ def test_video_polls_router_charges_quoted_price_and_never_sends_token_to_cdn(fa
     session = FakeSession(["IN_PROGRESS", "COMPLETED"])
     use(session)
     budget = Budget(5, 0.15, 0.5)
-    media = human_video.FalMedia("hf_token", budget, lambda: 3600, poll_interval=0)
+    media = human_video.FalMedia("hf_token", budget, None, poll_interval=0)
     assert media.image_to_video(Image.new("RGB", (64, 48)), "a prompt") == b"mp4-bytes"
     assert seen["task"] == "image-text-to-video" and seen["model"] == "MiniMaxAI/MiniMax-H3"
     assert seen["parameters"] == {"prompt": "a prompt", "resolution": "480P", "duration": 5}
@@ -423,7 +445,8 @@ def test_video_polls_router_charges_quoted_price_and_never_sends_token_to_cdn(fa
     assert [c[1] for c in session.calls if c[0] == "get"][:2] == [status_url, status_url]
     cdn = [c for c in session.calls if c[1].startswith("https://cdn.fal.media")]
     assert cdn and cdn[0][2] is None
-    assert budget.summary()["media_usd"] == pytest.approx(human_video_profile()["video_usd"])
+    assert budget.summary()["media_usd"] == pytest.approx(0.05 * 5)
+    assert budget.reserved == pytest.approx(0.05 * 5)
 
 
 def test_video_is_not_started_without_runtime_for_it(fal):
@@ -431,7 +454,7 @@ def test_video_is_not_started_without_runtime_for_it(fal):
     session = FakeSession([])
     use(session)
     budget = Budget(5, 0.15, 0.5)
-    media = human_video.FalMedia("hf_token", budget, lambda: 60, poll_interval=0)
+    media = human_video.FalMedia("hf_token", budget, time.time() + 60, poll_interval=0)
     with pytest.raises(DeadlineExceededError):
         media.image_to_video(Image.new("RGB", (64, 48)), "a prompt")
     assert session.calls == [] and budget.summary()["media_requests"] == 0
@@ -483,3 +506,40 @@ def test_media_endpoint_serves_only_generated_files(monkeypatch):
     assert "secret-token" not in json.dumps(listed)
     anonymous = TestClient(server.app).get("/api/jobs/job1/media?path=" + listed[0]["video"].split("=")[1])
     assert anonymous.status_code == 401
+
+
+def test_jobs_without_a_runtime_limit_still_generate_videos():
+    """Regression: the first run skipped every video because no runtime limit was set."""
+    from worker import video_deadline
+
+    manifest = {"costs": {"hours": 4}}
+    deadline = video_deadline(None, manifest, now=1000.0)
+    assert deadline == 1000.0 + 4 * 3600 - 900
+    assert video_deadline(5000.0, manifest) == 5000.0
+    media = human_video.FalMedia("t", Budget(5, 0.15, 0.5), video_deadline(None, manifest))
+    media.check_time()  # hours of runtime left: no DeadlineExceededError
+    assert human_video.FalMedia("t", Budget(5, 0.15, 0.5), None).time_left() == float("inf")
+
+
+def test_no_edit_is_paid_for_when_the_video_could_not_finish(tmp_path, episode):
+    media = FakeMedia(out_of_time=True)
+    result = annotate(tmp_path, episode, media, segments=0)
+    assert result["status"] == "completed"
+    assert media.edits == [] and media.videos == []
+    assert set(result["human_videos"]) <= {"time_stopped", "skipped"}
+
+
+def test_older_pinned_profiles_get_current_price_fields():
+    old = {
+        k: v
+        for k, v in human_video_profile().items()
+        if k not in ("edit_usd_per_megapixel", "video_usd_per_second")
+    }
+    media = human_video.FalMedia("t", Budget(5, 0.15, 0.5), None, old)
+    assert media.profile["edit_usd_per_megapixel"] == 0.03 and media.profile["video_usd_per_second"] == 0.05
+
+
+def test_failed_segments_record_a_short_reason(tmp_path, episode):
+    result = annotate(tmp_path, episode, FakeMedia(fail_first=True))
+    failed = next(e for e in result["human_video_entries"] if e["status"] == "failed")
+    assert failed["error_type"] == "RuntimeError" and failed["error"] == "provider error"

worker.py

@@ -301,6 +301,18 @@ def _annotate_episode(record, row, info, root, manifest, provider, staging_dir,
 HUMAN_VIDEO_DIR = "annotation_studio/human_videos"
 
 
+def video_deadline(deadline, manifest, now=None):
+    """When videos must stop: the runtime limit if one was set, else the job timeout.
+
+    Without a runtime limit the job still stops at its timeout (counted from job start, before
+    setup), so keep a 15 minute margin for setup and the final commits.
+    """
+    if deadline:
+        return deadline
+    now = time.time() if now is None else now
+    return now + manifest["costs"]["hours"] * 3600 - 900
+
+
 def human_video_operations(entries, index):
     """Upload an episode's media and the updated index (source episode IDs until materialized)."""
     operations = []
@@ -422,7 +434,7 @@ def run(manifest, work=Path("/workspace/run")):
         FalMedia(
             token,
             budget,
-            provider.remaining_time,
+            video_deadline(deadline, manifest),
             manifest["human_video"]["profile"],
             concurrency=manifest["human_video"].get("parallel"),
         )