davinci-resolve-mcp 2.54.4 → 2.55.0

package/CHANGELOG.md

@@ -2,6 +2,55 @@
 
 Release history for the DaVinci Resolve MCP Server. The latest release is summarized in the root README; older entries live here to keep the README focused.
 
+## What's New in v2.55.0
+
+Governance for catastrophic Media Pool deletes (exhaustive audit EX2/EX3).
+
+**Behavior change:** `media_pool` `delete_clips`, `delete_folders`, and
+`delete_timelines` now require a confirm token, the same two-step handshake
+`timeline.delete_track` already uses — the first call returns
+`status: "confirmation_required"` with a `confirm_token` and a preview (count +
+names); re-call with `params.confirm_token` to execute. Callers that disable
+gating via the `destructive.require_confirm_token=false` preference are
+unaffected.
+
+- **Fixed** the destructive-action registry listed granular function names
+  (`delete_media_pool_clips`, `move_media_pool_folders`, …) that the compound
+  `media_pool` tool never dispatches, so `is_destructive()` returned False and
+  these catastrophic deletes silently skipped version-on-mutate archiving and
+  change logging. The registry now uses the real compound action strings, so the
+  deletes are archived/logged as intended.
+- **Added** confirm-token gating + previews to the three deletes (EX3). The
+  registry fix also re-enables the existing media-pool change log for them.
+- Live-validated against DaVinci Resolve Studio 21.0.0 (non-destructively): the
+  no-token call returns `confirmation_required` and deletes nothing.
+
+## What's New in v2.54.5
+
+Reliability + security hardening from the exhaustive reliability audit (Wave A).
+
+- **Security** `apply_spec` hooks no longer run with `shell=True`. A spec's hook
+  command is now `shlex`-split and executed without a shell, so a hook string
+  can't inject arbitrary shell (`; rm -rf …`, pipes, expansion). Hooks needing
+  shell features must invoke an interpreter explicitly (e.g. `bash -c "…"`).
+- **Fixed** the confirm-token table (`_CONFIRM_TOKENS`) is now guarded by a lock.
+  The control panel is threaded, so issue/consume/GC ran concurrently; validate-
+  then-pop is now atomic and GC can't race a write.
+- **Fixed** negative item indices are rejected instead of silently returning the
+  wrong item (Python reverse-indexing): `_get_item`, the audio item resolver, and
+  the two timeline-matte helpers now require `0 <= index < len`.
+- **Fixed** history queries clamp `limit` to `[1, 1000]`. SQLite treats a negative
+  `LIMIT` as "no limit", so a negative value could silently fetch the entire table
+  (`get_brain_edit_history`, `list_runs`, `get_media_pool_change_history`).
+  `timeline_versioning` version/limit/keep_n params are now validated (no unhandled
+  `ValueError`; `rollback` rejects negative versions before archiving). `max_files`
+  /`max_seconds` in the relink file search are clamped positive.
+- **Fixed** the server-reachable ffmpeg probes (render, audio, review) now pass
+  `timeout=120` so a hung ffmpeg can't block the server indefinitely.
+
+(Deferred to a live-validated follow-up: confirm-token gating + archiving for
+catastrophic media-pool/take/fusion deletes, and temp-directory lifecycle cleanup.)
+
 ## What's New in v2.54.4
 
 Persistence-safety hardening (generalizes issue #71 to the analysis state

package/README.md

@@ -1,6 +1,6 @@
 # DaVinci Resolve MCP Server
 
-[![Version](https://img.shields.io/badge/version-2.54.4-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.55.0-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
 [![npm](https://img.shields.io/npm/v/davinci-resolve-mcp.svg?label=npm&color=CB3837)](https://www.npmjs.com/package/davinci-resolve-mcp)
 [![API Coverage](https://img.shields.io/badge/API%20Coverage-100%25-brightgreen.svg)](docs/reference/api-coverage.md)
 [![Tools](https://img.shields.io/badge/MCP%20Tools-34%20(341%20full)-blue.svg)](#server-modes)

package/install.py

@@ -35,7 +35,7 @@ from src.utils.update_check import (
 
 # ─── Version ──────────────────────────────────────────────────────────────────
 
-VERSION = "2.54.4"
+VERSION = "2.55.0"
 # Only hard floor: mcp[cli] requires Python 3.10+. There is no upper bound —
 # Resolve's scripting bridge loads into newer interpreters on recent builds
 # (Python 3.14 verified against Resolve Studio 20.3.2). Older Resolve builds

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "davinci-resolve-mcp",
-  "version": "2.54.4",
+  "version": "2.55.0",
   "description": "NPM bootstrapper for the DaVinci Resolve MCP Server.",
   "license": "MIT",
   "author": "Samuel Gursky <samgursky@gmail.com>",

package/src/granular/common.py

@@ -80,7 +80,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "2.54.4"
+VERSION = "2.55.0"
 logger = logging.getLogger("davinci-resolve-mcp")
 logger.info(f"Starting DaVinci Resolve MCP Server v{VERSION}")
 logger.info(f"Detected platform: {get_platform()}")

package/src/granular/media_pool.py

@@ -574,7 +574,7 @@ def get_timeline_matte_list(item_index: int = 0, track_type: str = "video", trac
     if not tl:
         return {"error": "No current timeline"}
     items = tl.GetItemListInTrack(track_type, track_index)
-    if not items or item_index >= len(items):
+    if not items or item_index < 0 or item_index >= len(items):  # reject negatives (EX5)
         return {"error": f"No item at index {item_index}"}
     mattes = mp.GetTimelineMatteList(items[item_index])
     return {"mattes": mattes if mattes else []}

package/src/granular/media_storage.py

@@ -171,7 +171,7 @@ def add_timeline_mattes_to_media_pool(timeline_item_index: int, matte_paths: Lis
         return {"error": "No current timeline"}
 
     items = timeline.GetItemListInTrack(track_type, track_index)
-    if not items or timeline_item_index >= len(items):
+    if not items or timeline_item_index < 0 or timeline_item_index >= len(items):  # reject negatives (EX5)
         return {"error": f"Timeline item at index {timeline_item_index} not found"}
 
     item = items[timeline_item_index]

package/src/server.py

@@ -11,7 +11,7 @@ Usage:
     python src/server.py --full       # Start the 341-tool granular server instead
 """
 
-VERSION = "2.54.4"
+VERSION = "2.55.0"
 
 import base64
 import os
@@ -784,6 +784,11 @@ _destructive_hook.register_preference_provider(_destructive_preference_provider)
 _TOKEN_GATED_DESTRUCTIVE_ACTIONS = frozenset({
     ("timeline", "delete_track"),
     ("timeline", "apply_cuts"),
+    # Catastrophic media-pool deletes (EX3): irreversibly destroy clips/folders/
+    # timelines. Gated like delete_track; also archive-on-mutate via the registry.
+    ("media_pool", "delete_clips"),
+    ("media_pool", "delete_folders"),
+    ("media_pool", "delete_timelines"),
     # Phase E edit-engine loops: plan → confirm → execute.
     ("edit_engine", "execute_selects"),
     ("edit_engine", "execute_tighten"),
@@ -1006,6 +1011,10 @@ import uuid as _uuid
 
 
 _CONFIRM_TOKENS: Dict[str, Dict[str, Any]] = {}
+# The control panel runs on a threaded HTTP server, so issue/consume/gc of the
+# token table run on concurrent threads. Guard every access so a GC iteration
+# can't race a write and validate-then-pop stays atomic (EX4).
+_CONFIRM_TOKENS_LOCK = threading.RLock()
 _CONFIRM_TTL_SECONDS = 300
 
 
@@ -1023,11 +1032,13 @@ def _confirm_token_fingerprint(action: str, params: Optional[Dict[str, Any]]) ->
 
 
 def _confirm_token_gc():
-    """Drop expired tokens; called on every issue/validate."""
+    """Drop expired tokens; called on every issue/validate. Caller may already
+    hold _CONFIRM_TOKENS_LOCK (RLock makes re-entry safe)."""
     now = _time.time()
-    expired = [t for t, rec in _CONFIRM_TOKENS.items() if rec.get("expires_at", 0) < now]
-    for t in expired:
-        _CONFIRM_TOKENS.pop(t, None)
+    with _CONFIRM_TOKENS_LOCK:
+        expired = [t for t, rec in _CONFIRM_TOKENS.items() if rec.get("expires_at", 0) < now]
+        for t in expired:
+            _CONFIRM_TOKENS.pop(t, None)
 
 
 def _confirm_token_required() -> bool:
@@ -1045,16 +1056,17 @@ def _confirm_token_required() -> bool:
 
 def _issue_confirm_token(*, action: str, params: Optional[Dict[str, Any]], preview: Dict[str, Any]) -> Dict[str, Any]:
     """Mint a token. Returns the pending_user_decision response shape."""
-    _confirm_token_gc()
     token = _uuid.uuid4().hex
     fp = _confirm_token_fingerprint(action, params)
     expires_at = _time.time() + _CONFIRM_TTL_SECONDS
-    _CONFIRM_TOKENS[token] = {
-        "action": action,
-        "fingerprint": fp,
-        "expires_at": expires_at,
-        "issued_at": _time.time(),
-    }
+    with _CONFIRM_TOKENS_LOCK:
+        _confirm_token_gc()
+        _CONFIRM_TOKENS[token] = {
+            "action": action,
+            "fingerprint": fp,
+            "expires_at": expires_at,
+            "issued_at": _time.time(),
+        }
     body = _err(
         f"This action is destructive. Re-call with confirm_token to proceed.",
         code="CONFIRMATION_REQUIRED",
@@ -1082,8 +1094,9 @@ def _consume_confirm_token(*, action: str, params: Optional[Dict[str, Any]]) ->
     token = (params or {}).get("confirm_token") or (params or {}).get("confirmToken")
     if not token:
         return None  # Caller is expected to call _issue_confirm_token in this case.
-    _confirm_token_gc()
-    rec = _CONFIRM_TOKENS.pop(token, None)  # one-time use
+    with _CONFIRM_TOKENS_LOCK:
+        _confirm_token_gc()
+        rec = _CONFIRM_TOKENS.pop(token, None)  # one-time use, atomic with gc
     if rec is None:
         return _err(
             "confirm_token is invalid, expired, or was issued by a different "
@@ -1855,7 +1868,9 @@ def _get_item(p):
     track_index = p.get("track_index", 1)
     item_index = p.get("item_index", 0)
     items = tl.GetItemListInTrack(track_type, track_index)
-    if not items or item_index >= len(items):
+    # Reject negatives explicitly: Python's reverse-indexing would otherwise
+    # silently return the wrong item for item_index < 0 (EX5).
+    if not items or not isinstance(item_index, int) or item_index < 0 or item_index >= len(items):
         return tl, None, _err(
             f"No item at index {item_index} on {track_type} track {track_index}",
             code="ITEM_INDEX_OUT_OF_RANGE", category="invalid_input",
@@ -5494,8 +5509,10 @@ def _bounded_basename_matches(
     p: Dict[str, Any],
 ) -> Tuple[List[str], Dict[str, Any]]:
     started = time.monotonic()
-    max_seconds = float(p.get("max_seconds", p.get("timeout_seconds", 20)) or 20)
-    max_files = int(p.get("max_files_scanned", p.get("maxFilesScanned", 50000)) or 50000)
+    # Clamp to positive: a negative max_seconds/max_files would trip the
+    # >= guards on the first iteration and silently return no results (EX8).
+    max_seconds = max(0.1, float(p.get("max_seconds", p.get("timeout_seconds", 20)) or 20))
+    max_files = max(1, int(p.get("max_files_scanned", p.get("maxFilesScanned", 50000)) or 50000))
     max_depth_raw = p.get("max_depth", p.get("maxDepth"))
     max_depth = int(max_depth_raw) if max_depth_raw is not None else None
     all_matches = bool(p.get("all_matches", False))
@@ -5704,7 +5721,7 @@ def _audio_item_from_params(tl, p: Dict[str, Any]):
     track_index = int(p.get("track_index", 1))
     item_index = int(p.get("item_index", 0))
     items = tl.GetItemListInTrack(track_type, track_index) or []
-    if item_index >= len(items):
+    if item_index < 0 or item_index >= len(items):  # reject negatives (EX5)
         return None, _err(f"No item at index {item_index} on {track_type} track {track_index}")
     return items[item_index], None
 
@@ -7474,6 +7491,23 @@ def _setup_positive_int(value: Any, default: int, min_value: int = 0, max_value:
     return max(min_value, min(parsed, max_value))
 
 
+def _safe_int(value: Any, default: int, *, minimum: Optional[int] = None, maximum: Optional[int] = None) -> int:
+    """Coerce a tool param to int without throwing; clamp to [minimum, maximum].
+
+    Used by action handlers so a non-numeric or out-of-range numeric param yields
+    a sane value instead of an unhandled ValueError or a SQLite "negative LIMIT =
+    no limit" full-table fetch (EX8)."""
+    try:
+        parsed = int(value)
+    except (TypeError, ValueError):
+        parsed = default
+    if minimum is not None:
+        parsed = max(minimum, parsed)
+    if maximum is not None:
+        parsed = min(parsed, maximum)
+    return parsed
+
+
 def _setup_marker_limit(value: Any, default: int = 12) -> int:
     if isinstance(value, str) and _setup_text_key(value) in {"unlimited", "no_limit", "nolimit", "all"}:
         return 0
@@ -13673,14 +13707,29 @@ class _SpecLiveExecutor:
 
 
 def _make_spec_hook_runner(timeout: float = 120.0):
-    """Return a callable that runs a Hook's shell command (opt-in only)."""
+    """Return a callable that runs a Hook's command (opt-in only).
+
+    The command is split with shlex and run WITHOUT a shell, so a spec's hook
+    string cannot inject arbitrary shell (`; rm -rf …`, pipes, expansion). A
+    hook that needs shell features must invoke an explicit interpreter
+    (e.g. ``bash -c "…"``) as its own argv, making the intent visible (EX1).
+    """
+    import shlex
     import subprocess
 
     def _run(hook) -> bool:
+        try:
+            argv = shlex.split(hook.command or "")
+        except ValueError as exc:
+            logger.warning("spec hook '%s' has an unparseable command: %s", hook.name or hook.command, exc)
+            return False
+        if not argv:
+            logger.warning("spec hook '%s' has an empty command", hook.name or "")
+            return False
         try:
             proc = subprocess.run(
-                hook.command,
-                shell=True,
+                argv,
+                shell=False,
                 timeout=timeout,
                 stdin=subprocess.DEVNULL,
                 capture_output=True,
@@ -14891,7 +14940,20 @@ def media_pool(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[str
             for sub in (root.GetSubFolderList() or []):
                 if sub.GetUniqueId() == fid:
                     folders.append(sub)
-        return {"success": bool(mp.DeleteFolders(folders))} if folders else _err("No folders found")
+        if not folders:
+            return _err("No folders found")
+        if "confirm_token" not in p and "confirmToken" not in p and _confirm_token_required():
+            return _issue_confirm_token(
+                action="media_pool.delete_folders", params=p,
+                preview={"operation": "media_pool.delete_folders",
+                         "warning": "Permanently deletes folders AND every clip they contain.",
+                         "folders_lost": len(folders),
+                         "names": [_clip_name(f) for f in folders][:25]},
+            )
+        blocked = _consume_confirm_token(action="media_pool.delete_folders", params=p)
+        if blocked:
+            return blocked
+        return {"success": bool(mp.DeleteFolders(folders))}
     elif action == "move_folders":
         target = _navigate_folder(mp, p["target_path"])
         if not target:
@@ -14984,7 +15046,20 @@ def media_pool(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[str
             tl = proj.GetTimelineByIndex(i)
             if tl and tl.GetUniqueId() in p["timeline_ids"]:
                 timelines.append(tl)
-        return {"success": bool(mp.DeleteTimelines(timelines))} if timelines else _err("No timelines found")
+        if not timelines:
+            return _err("No timelines found")
+        if "confirm_token" not in p and "confirmToken" not in p and _confirm_token_required():
+            return _issue_confirm_token(
+                action="media_pool.delete_timelines", params=p,
+                preview={"operation": "media_pool.delete_timelines",
+                         "warning": "Permanently deletes timelines.",
+                         "timelines_lost": len(timelines),
+                         "names": [t.GetName() for t in timelines][:25]},
+            )
+        blocked = _consume_confirm_token(action="media_pool.delete_timelines", params=p)
+        if blocked:
+            return blocked
+        return {"success": bool(mp.DeleteTimelines(timelines))}
     elif action == "append_to_timeline":
         if p.get("clip_infos") is not None:
             raw = p["clip_infos"]
@@ -15071,7 +15146,20 @@ def media_pool(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[str
     elif action == "delete_clips":
         clips = [_find_clip(root, cid) for cid in p["clip_ids"]]
         clips = [c for c in clips if c]
-        return {"success": bool(mp.DeleteClips(clips))} if clips else _err("No clips found")
+        if not clips:
+            return _err("No clips found")
+        if "confirm_token" not in p and "confirmToken" not in p and _confirm_token_required():
+            return _issue_confirm_token(
+                action="media_pool.delete_clips", params=p,
+                preview={"operation": "media_pool.delete_clips",
+                         "warning": "Permanently deletes Media Pool clips.",
+                         "clips_lost": len(clips),
+                         "names": [_clip_name(c) for c in clips][:25]},
+            )
+        blocked = _consume_confirm_token(action="media_pool.delete_clips", params=p)
+        if blocked:
+            return blocked
+        return {"success": bool(mp.DeleteClips(clips))}
     elif action == "move_clips":
         target = _navigate_folder(mp, p["target_path"])
         if not target:
@@ -15965,7 +16053,7 @@ async def media_analysis(action: str, params: Optional[Dict[str, Any]] = None, c
             _r, _proj, project_root, _name = vctx
             session_only = bool(p.get("session_only", False))
             session_id = _AI_LEDGER_SESSION_ID if session_only else None
-            limit = int(p.get("limit", 50))
+            limit = _safe_int(p.get("limit"), 50, minimum=1, maximum=1000)
             return {
                 "success": True,
                 "session_id": _AI_LEDGER_SESSION_ID,
@@ -16821,7 +16909,7 @@ def timeline_versioning(action: str, params: Optional[Dict[str, Any]] = None) ->
     if action == "list_runs":
         return {
             "success": True,
-            "runs": _analysis_runs.list_runs(project_root, limit=int(p.get("limit", 50))),
+            "runs": _analysis_runs.list_runs(project_root, limit=_safe_int(p.get("limit"), 50, minimum=1, maximum=1000)),
         }
     if action == "archive_current":
         return _timeline_versioning.archive_current_timeline(
@@ -16842,13 +16930,18 @@ def timeline_versioning(action: str, params: Optional[Dict[str, Any]] = None) ->
     if action == "diff_versions":
         if not p.get("timeline_name") or "from_version" not in p or "to_version" not in p:
             return _err("timeline_name, from_version, to_version required")
+        try:
+            from_version = int(p["from_version"])
+            to_version = int(p["to_version"])
+        except (TypeError, ValueError):
+            return _err("from_version and to_version must be integers")
         return {
             "success": True,
             **_timeline_versioning.diff_versions(
                 project_root=project_root,
                 timeline_name=str(p["timeline_name"]),
-                from_version=int(p["from_version"]),
-                to_version=int(p["to_version"]),
+                from_version=from_version,
+                to_version=to_version,
             ),
         }
     if action == "diff_timelines":
@@ -16864,18 +16957,24 @@ def timeline_versioning(action: str, params: Optional[Dict[str, Any]] = None) ->
             project_root=project_root,
             timeline_name=p.get("timeline_name"),
             analysis_run_id=p.get("analysis_run_id"),
-            limit=int(p.get("limit", 50)),
+            limit=_safe_int(p.get("limit"), 50, minimum=1, maximum=1000),
         )
         return {"success": True, "edits": rows}
     if action == "rollback":
         if not p.get("timeline_name") or "version" not in p:
             return _err("timeline_name and version required")
+        try:
+            version = int(p["version"])
+        except (TypeError, ValueError):
+            return _err("version must be an integer")
+        if version < 0:
+            return _err("version must be >= 0")
         return _timeline_versioning.rollback_to_version(
             resolve=resolve_h,
             project=project_h,
             project_root=project_root,
             timeline_name=str(p["timeline_name"]),
-            version=int(p["version"]),
+            version=version,
             analysis_run_id=p.get("analysis_run_id"),
         )
     if action == "prune":
@@ -16886,7 +16985,7 @@ def timeline_versioning(action: str, params: Optional[Dict[str, Any]] = None) ->
             project=project_h,
             project_root=project_root,
             timeline_name=str(p["timeline_name"]),
-            keep_n=int(p.get("keep_n", 10)),
+            keep_n=_safe_int(p.get("keep_n"), 10, minimum=1, maximum=1000),
         )
     if action == "registry":
         return {"success": True, **_brain_edits.read_brain_edits_registry(project_root)}
@@ -16897,7 +16996,7 @@ def timeline_versioning(action: str, params: Optional[Dict[str, Any]] = None) ->
                 project_root=project_root,
                 analysis_run_id=p.get("analysis_run_id"),
                 action=p.get("media_pool_action"),
-                limit=int(p.get("limit", 50)),
+                limit=_safe_int(p.get("limit"), 50, minimum=1, maximum=1000),
             ),
         }
     return _err(f"Unknown action: {action}")

package/src/utils/analysis_runs.py

@@ -234,6 +234,11 @@ def get_run(project_root: str, analysis_run_id: str) -> Optional[Dict[str, Any]]
 
 
 def list_runs(project_root: str, *, limit: int = 50) -> List[Dict[str, Any]]:
+    # SQLite treats a negative LIMIT as "no limit"; clamp (EX8).
+    try:
+        limit = max(1, min(1000, int(limit)))
+    except (TypeError, ValueError):
+        limit = 50
     conn = timeline_brain_db.connect(project_root)
     rows = conn.execute(
         """

package/src/utils/audio_fairlight_live_probe.py

@@ -47,7 +47,7 @@ def _record_tool_result(
 
 
 def _run_ffmpeg(args: list[str]) -> None:
-    subprocess.run(["ffmpeg", "-hide_banner", "-loglevel", "error", *args], check=True)
+    subprocess.run(["ffmpeg", "-hide_banner", "-loglevel", "error", *args], check=True, timeout=120)
 
 
 def _make_synthetic_media(work_dir: Path) -> Dict[str, Path]:

package/src/utils/brain_edits.py

@@ -278,6 +278,12 @@ def get_brain_edit_history(
     limit: int = 50,
 ) -> List[Dict[str, Any]]:
     """Return brain_edit rows, optionally filtered by timeline or run, newest first."""
+    # SQLite treats a negative LIMIT as "no limit"; clamp so a negative/huge
+    # limit can't silently fetch the whole table (EX8).
+    try:
+        limit = max(1, min(1000, int(limit)))
+    except (TypeError, ValueError):
+        limit = 50
     conn = timeline_brain_db.connect(project_root)
     clauses: List[str] = []
     args: List[Any] = []

package/src/utils/destructive_hook.py

@@ -41,18 +41,17 @@ logger = logging.getLogger("resolve-mcp.destructive-hook")
 # default metric.
 
 DESTRUCTIVE_ACTIONS_BY_TOOL: Dict[str, FrozenSet[str]] = {
+    # Real COMPOUND media_pool action strings (the @destructive_op("media_pool")
+    # wrapper queries is_destructive("media_pool", <compound action>)). The prior
+    # entries used granular function names (delete_media_pool_clips, …) and
+    # media_pool_item names that the compound tool never dispatches, so catastrophic
+    # deletes silently bypassed version-on-mutate archiving (EX2). media_pool_item
+    # link/replace actions are governed separately (its own tool is not yet wrapped).
     "media_pool": frozenset({
-        "delete_media_pool_clips",
-        "delete_media_pool_folders",
+        "delete_clips",
+        "delete_folders",
         "move_clips",
-        "move_media_pool_folders",
-        "replace_clip",
-        "replace_clip_preserve_sub_clip",
-        "link_clip_proxy_media",
-        "unlink_clip_proxy_media",
-        "link_proxy_media",
-        "unlink_proxy_media",
-        "link_clip_full_resolution_media",
+        "move_folders",
         "delete_clip_mattes",
         "delete_timelines",
     }),

package/src/utils/media_pool_changes.py

@@ -84,6 +84,11 @@ def get_media_pool_change_history(
     action: Optional[str] = None,
     limit: int = 50,
 ) -> List[Dict[str, Any]]:
+    # SQLite treats a negative LIMIT as "no limit"; clamp (EX8).
+    try:
+        limit = max(1, min(1000, int(limit)))
+    except (TypeError, ValueError):
+        limit = 50
     conn = timeline_brain_db.connect(project_root)
     clauses: List[str] = []
     args: List[Any] = []

package/src/utils/render_deliver_live_probe.py

@@ -59,7 +59,7 @@ def _record_tool_result(
 
 
 def _run_ffmpeg(args: list[str]) -> None:
-    subprocess.run(["ffmpeg", "-hide_banner", "-loglevel", "error", *args], check=True)
+    subprocess.run(["ffmpeg", "-hide_banner", "-loglevel", "error", *args], check=True, timeout=120)
 
 
 def _make_synthetic_video(work_dir: Path) -> Path:

package/src/utils/review_annotation_live_probe.py

@@ -59,7 +59,7 @@ def _record_tool_result(
 
 
 def _run_ffmpeg(args: list[str]) -> None:
-    subprocess.run(["ffmpeg", "-hide_banner", "-loglevel", "error", *args], check=True)
+    subprocess.run(["ffmpeg", "-hide_banner", "-loglevel", "error", *args], check=True, timeout=120)
 
 
 def _make_synthetic_video(work_dir: Path) -> Path: