davinci-resolve-mcp 2.98.1 → 2.98.3

package/CHANGELOG.md

@@ -2,6 +2,130 @@
 
 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.98.3
+
+**`fusion_comp` could never delete a Fusion keyframe.** Reported in
+[#155](https://github.com/samuelgursky/davinci-resolve-mcp/issues/155) by
+@Andrei-59, with the root cause already identified: the handler called a method
+that does not exist. The diagnosis was correct, and the suggested replacement is
+confirmed here against a live build.
+
+### Fixed
+
+- **`delete_keyframe` called `RemoveKeyFrame()` on a Fusion Input.** No such
+  method exists there. Keyframes do not live on the Input — they live on the
+  spline modifier connected to it, which is what `add_keyframe` attaches via
+  `AddModifier(input_name, "BezierSpline")`. The action now reaches that spline
+  through `inp.GetConnectedOutput().GetTool()` and calls `DeleteKeyFrames(time)`
+  on it. Introduced with the tool in v2.1.0 and broken for every input, every
+  frame, and every tool since; there is no version of the server in which it
+  worked.
+
+- **The failure surfaced as `'NoneType' object is not callable`.** The
+  fusionscript bridge resolves an unknown attribute to `None` instead of raising
+  `AttributeError`, so the bad lookup succeeded silently and only died at the
+  callsite — an error naming neither the method nor the object. Every branch of
+  the action now returns the normal error envelope: `FUSION_INPUT_NOT_ANIMATED`
+  when the input has no modifier, `FUSION_KEYFRAME_NOT_FOUND` when nothing is
+  keyed at that frame (the frame list is included in `state`),
+  `FUSION_DELETE_KEYFRAMES_UNSUPPORTED` when the modifier has no removal method,
+  and `INVALID_FRAME` for a non-numeric `time`. The existing `_has_method` guard
+  — which exists precisely for this silent-`None` class — is applied before the
+  call rather than after it.
+
+- **Success is verified by readback, not by the return value.** Live testing
+  showed `DeleteKeyFrames()` returns `None` whether or not it removed anything,
+  so trusting the return would have reported failure on every successful
+  delete — and trusting the absence of an exception would have reported success
+  on every silent no-op. The handler re-reads the keyframe list and returns
+  `FUSION_DELETE_KEYFRAME_NOOP` if the frame is still there. On success it
+  returns `{success, time, remaining_keyframes}`.
+
+### Testing
+
+- `tests/test_fusion_comp_targeting.py` gains eleven `delete_keyframe` cases,
+  including a regression test that models the bridge's silent-`None` attribute
+  lookup and asserts the handler never reaches for `RemoveKeyFrame` on the
+  Input. The action previously had no test coverage at all.
+- `tests/live_fusion_delete_keyframe_validation.py` is a new self-contained live
+  harness: it creates a scratch project, inserts a Fusion composition clip (no
+  media needed), and reports which keyframe methods the Input and the spline
+  actually expose before asserting the delete.
+
+### Verified live
+
+Validated on **DaVinci Resolve Studio 19.1.3.7** (macOS). `RemoveKeyFrame`
+confirmed absent on the Input and resolving to `None`; `DeleteKeyFrames`
+confirmed present on the `BezierSpline` and confirmed to remove the key. The
+reporter's exact reproduction — `add_keyframe` then `delete_keyframe` on the
+same tool/input/frame — was run end-to-end through the patched handler and
+succeeds. Not re-verified on Studio 21.0.4.5, the reporter's build.
+
+## What's New in v2.98.2
+
+**A tool installed next to the server was invisible to it.** Reported in
+[#153](https://github.com/samuelgursky/davinci-resolve-mcp/issues/153) by
+@7daysdedicated as an encoding fault in the whisper probe. The probe turned out
+not to be the cause, and the encoding fault turned out to be real somewhere
+else, so both are fixed here.
+
+### Fixed
+
+- **The server's own virtualenv was not searched for command-line tools.**
+  `pip install openai-whisper` writes a `whisper` executable into
+  `venv/Scripts` on Windows and `venv/bin` elsewhere, and that directory is on
+  PATH only while the environment is *activated* — which nothing does, since the
+  client launches `venv/python server.py` directly. So `shutil.which("whisper")`
+  returned None and `capabilities` reported `whisper_cli.available: false` for a
+  tool sitting beside the interpreter looking for it, with nothing in the
+  response to say why. The interpreter's script directory now leads the PATH
+  augmentation that already covered Homebrew and `/usr/local`. Not
+  Windows-specific: the same gap existed on macOS and Linux.
+
+- **Text-mode reads of a child process decoded with the locale codec.** Nineteen
+  `subprocess.run(..., text=True)` calls across the server, panel, and utils had
+  no `encoding=`, so Python used the platform locale — cp1252 on a default
+  Windows install, a codec with no mapping for most of what a media tool prints.
+  A clip name in Japanese from the advanced-server bridge, a localized WMIC
+  banner, or a user script's output was then a `UnicodeDecodeError` raised
+  inside a call whose job was to answer a yes/no question. All nineteen now read
+  UTF-8 with `errors="replace"`, so the answer can be wrong in the last
+  character but never an exception. The WMIC read matters most: it feeds the
+  second-instance guard fixed in v2.97.6, and it must fail to "cannot tell".
+
+- **Child Python processes are handed `PYTHONIOENCODING=utf-8`.** A script run
+  through `resolve_control` writes into a pipe, where Python picks the locale
+  codepage rather than the console's, so printing a non-Latin-1 character killed
+  the script with `UnicodeEncodeError` — and the failure read as the script's
+  fault rather than the pipe's. The transcription path already did this; the
+  script-runner did not.
+
+### Added
+
+- **`tests.test_child_process_text_encoding`** — a static walk over `src/` that
+  fails on any text-mode child read without an explicit `encoding=`. Static
+  because the exception needs a non-UTF-8 locale to reproduce and no machine in
+  this suite has one: the missing argument is visible in the source, the
+  `UnicodeDecodeError` is only visible in Tokyo. The walk carries a test that it
+  can still see an offender, since a guard that quietly matches nothing passes
+  forever. Also covers the venv script directory being on PATH, first, and
+  idempotently.
+
+### Note on the report
+
+The diagnosis in #153 named `whisper --help` as the probe. That string is
+display text in the install-guidance table and is never executed — detection is
+`shutil.which("whisper")` — and the transcription path already decoded UTF-8 and
+already set `PYTHONIOENCODING`. The cause was the PATH gap the report mentioned
+last, in passing, as an aside about `pip`. Worth stating plainly, because the
+reporter's `whisper.cmd` workaround set the encoding *and* put a `whisper` on
+PATH, and only the second half was doing the work.
+
+### Changed
+
+- `docs/install.md` says which environment optional packages have to be
+  installed into, which is the part that was undocumented.
+
 ## What's New in v2.98.1
 
 **The Bash guard could be walked past with a newline.** Reported and fixed in

package/README.md

@@ -2,7 +2,7 @@
 
 English | [简体中文](README.zh-CN.md)
 
-[![Version](https://img.shields.io/badge/version-2.98.1-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.98.3-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-35%20(353%20full)-blue.svg)](#server-modes)

package/README.zh-CN.md

@@ -2,7 +2,7 @@
 
 [English](README.md) | 简体中文
 
-[![Version](https://img.shields.io/badge/version-2.98.1-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.98.3-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-35%20(353%20full)-blue.svg)](#服务器模式)
@@ -12,7 +12,7 @@
 [![Python](https://img.shields.io/badge/python-3.10+-green.svg)](https://www.python.org/downloads/)
 [![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 
-> 本翻译对应 v2.98.1 版 README。如与英文原版有出入，以 [英文原版](README.md) 为准。
+> 本翻译对应 v2.98.3 版 README。如与英文原版有出入，以 [英文原版](README.md) 为准。
 
 一个 Model Context Protocol (MCP) 服务器，让 AI 助手通过官方脚本 API 控制 DaVinci Resolve Studio（达芬奇）。它提供完整的 API 覆盖，外加带护栏的工作流助手，涵盖剪辑、媒体池整理、渲染设置、审阅标记、调色、Fusion、Fairlight、项目生命周期任务、扩展开发，以及不碰源媒体的媒体分析。
 

package/docs/install.md

@@ -35,6 +35,14 @@ rather than guessing** if it is absent:
 `python scripts/doctor.py` reports which are present. `media_analysis`
 `capabilities` covers the analysis stack in more detail.
 
+**Install them into the environment the server runs from.** A managed install
+uses its own virtualenv, and `pip install` from an unrelated shell puts the
+package somewhere that interpreter never looks. Use the venv's own pip —
+`<install>/venv/bin/pip` (`venv\Scripts\pip.exe` on Windows) — or activate it
+first. Command-line tools that come with a package (`openai-whisper` installs a
+`whisper` executable) are found in that venv's script directory automatically
+since v2.98.2; before that they had to be on PATH by hand.
+
 Model weights carry their own licences, separate from the code that loads them.
 
 > **Python 3.13 / 3.14:** these are **allowed** — setup will use them and warn.

package/install.py

@@ -37,7 +37,7 @@ from src.utils.update_check import (
 
 # ─── Version ──────────────────────────────────────────────────────────────────
 
-VERSION = "2.98.1"
+VERSION = "2.98.3"
 # 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.98.1",
+  "version": "2.98.3",
   "description": "NPM bootstrapper for the DaVinci Resolve MCP Server.",
   "license": "MIT",
   "author": "Samuel Gursky <samgursky@gmail.com>",

package/src/analysis_dashboard.py

@@ -14569,7 +14569,8 @@ def _launch_claude_code_terminal() -> Dict[str, Any]:
     try:
         check = subprocess.run(
             ["osascript", "-e", 'application "iTerm" is running'],
-            capture_output=True, text=True, timeout=8,
+            capture_output=True, text=True, encoding="utf-8", errors="replace",
+            timeout=8,
         )
         iterm_running = (check.stdout or "").strip().lower() == "true"
     except Exception:
@@ -14592,7 +14593,8 @@ def _launch_claude_code_terminal() -> Dict[str, Any]:
     try:
         proc = subprocess.run(
             ["osascript", "-e", script],
-            capture_output=True, text=True, timeout=15,
+            capture_output=True, text=True, encoding="utf-8", errors="replace",
+            timeout=15,
         )
         if proc.returncode != 0:
             return {"success": False, "error": (proc.stderr or "").strip() or "osascript failed"}
@@ -14623,7 +14625,8 @@ def _native_directory_picker(initial: Optional[str] = None) -> Dict[str, Any]:
             import subprocess
             proc = subprocess.run(
                 ["osascript", "-e", script],
-                capture_output=True, text=True, timeout=120,
+                capture_output=True, text=True, encoding="utf-8", errors="replace",
+                timeout=120,
             )
             if proc.returncode != 0:
                 stderr = (proc.stderr or "").strip()
@@ -15194,7 +15197,11 @@ def _run_advanced_bridge(surface: str, op: str, args: Optional[Dict[str, Any]] =
         # stdin=DEVNULL: never let a child race-read a protocol/stdin stream (api_truth).
         proc = subprocess.run(
             [node, bridge, str(surface), str(op), json.dumps(args or {})],
-            capture_output=True, text=True, timeout=timeout,
+            # The bridge answers in JSON that carries clip and project names;
+            # decoding those with the locale codepage is how a non-ASCII name
+            # turns a working panel call into a UnicodeDecodeError (#153).
+            capture_output=True, text=True, encoding="utf-8", errors="replace",
+            timeout=timeout,
             stdin=subprocess.DEVNULL, cwd=_advanced_root(),
         )
     except subprocess.TimeoutExpired:

package/src/granular/common.py

@@ -87,7 +87,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "2.98.1"
+VERSION = "2.98.3"
 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/server.py

@@ -11,7 +11,7 @@ Usage:
     python src/server.py --full       # Start the 353-tool granular server instead
 """
 
-VERSION = "2.98.1"
+VERSION = "2.98.3"
 
 import base64
 import os
@@ -1724,8 +1724,8 @@ def _activate_resolve_window() -> Dict[str, Any]:
             import subprocess
             proc = subprocess.run(
                 ["osascript", "-e", 'tell application "DaVinci Resolve" to activate'],
-                capture_output=True, text=True, timeout=5,
-                stdin=subprocess.DEVNULL,
+                capture_output=True, text=True, encoding="utf-8", errors="replace",
+                timeout=5, stdin=subprocess.DEVNULL,
             )
             return {
                 "activated": proc.returncode == 0,
@@ -1738,8 +1738,8 @@ def _activate_resolve_window() -> Dict[str, Any]:
                 ["powershell", "-NoProfile", "-Command",
                  "$s = New-Object -ComObject WScript.Shell; "
                  "$null = $s.AppActivate('DaVinci Resolve')"],
-                capture_output=True, text=True, timeout=5,
-                stdin=subprocess.DEVNULL,
+                capture_output=True, text=True, encoding="utf-8", errors="replace",
+                timeout=5, stdin=subprocess.DEVNULL,
             )
             return {
                 "activated": proc.returncode == 0,
@@ -1751,8 +1751,8 @@ def _activate_resolve_window() -> Dict[str, Any]:
         if shutil.which("wmctrl"):
             proc = subprocess.run(
                 ["wmctrl", "-a", "DaVinci Resolve"],
-                capture_output=True, text=True, timeout=5,
-                stdin=subprocess.DEVNULL,
+                capture_output=True, text=True, encoding="utf-8", errors="replace",
+                timeout=5, stdin=subprocess.DEVNULL,
             )
             return {
                 "activated": proc.returncode == 0,
@@ -1762,8 +1762,8 @@ def _activate_resolve_window() -> Dict[str, Any]:
         if shutil.which("xdotool"):
             proc = subprocess.run(
                 ["xdotool", "search", "--name", "DaVinci Resolve", "windowactivate"],
-                capture_output=True, text=True, timeout=5,
-                stdin=subprocess.DEVNULL,
+                capture_output=True, text=True, encoding="utf-8", errors="replace",
+                timeout=5, stdin=subprocess.DEVNULL,
             )
             return {
                 "activated": proc.returncode == 0,
@@ -1794,8 +1794,8 @@ def _send_resolve_keystroke_go_to_mark_in() -> Dict[str, Any]:
             )
             proc = subprocess.run(
                 ["osascript", "-e", script],
-                capture_output=True, text=True, timeout=5,
-                stdin=subprocess.DEVNULL,
+                capture_output=True, text=True, encoding="utf-8", errors="replace",
+                timeout=5, stdin=subprocess.DEVNULL,
             )
             return {
                 "sent": proc.returncode == 0,
@@ -1810,8 +1810,8 @@ def _send_resolve_keystroke_go_to_mark_in() -> Dict[str, Any]:
                  "Add-Type -AssemblyName System.Windows.Forms; "
                  "Start-Sleep -Milliseconds 150; "
                  "[System.Windows.Forms.SendKeys]::SendWait('+i')"],
-                capture_output=True, text=True, timeout=5,
-                stdin=subprocess.DEVNULL,
+                capture_output=True, text=True, encoding="utf-8", errors="replace",
+                timeout=5, stdin=subprocess.DEVNULL,
             )
             return {
                 "sent": proc.returncode == 0,
@@ -1824,8 +1824,8 @@ def _send_resolve_keystroke_go_to_mark_in() -> Dict[str, Any]:
         if shutil.which("xdotool"):
             proc = subprocess.run(
                 ["xdotool", "search", "--name", "DaVinci Resolve", "key", "--window", "%@", "shift+i"],
-                capture_output=True, text=True, timeout=5,
-                stdin=subprocess.DEVNULL,
+                capture_output=True, text=True, encoding="utf-8", errors="replace",
+                timeout=5, stdin=subprocess.DEVNULL,
             )
             return {"sent": proc.returncode == 0, "platform": "linux", "tool": "xdotool", "shortcut": "Shift+I"}
         return {"sent": False, "platform": sys.platform, "note": "no key-send tool found"}
@@ -15286,7 +15286,8 @@ def _port_owner_pid(host: str, port: int) -> Optional[int]:
     try:
         result = subprocess.run(
             ["lsof", "-nP", "-iTCP:" + str(port), "-sTCP:LISTEN", "-t"],
-            capture_output=True, timeout=3, text=True, check=False,
+            capture_output=True, timeout=3, text=True, encoding="utf-8",
+            errors="replace", check=False,
             stdin=subprocess.DEVNULL,
         )
     except (OSError, subprocess.TimeoutExpired):
@@ -16561,6 +16562,8 @@ def _make_spec_hook_runner(timeout: float = 120.0):
                 stdin=subprocess.DEVNULL,
                 capture_output=True,
                 text=True,
+                encoding="utf-8",
+                errors="replace",
             )
             return proc.returncode == 0
         except Exception as exc:
@@ -26579,6 +26582,121 @@ def _fusion_set_text_plus(comp, p: Dict[str, Any]) -> Dict[str, Any]:
         comp.Unlock()
 
 
+def _fusion_keyframe_frames(inp) -> List[float]:
+    """Frame positions currently keyed on `inp`, as a sorted list.
+
+    Fusion's `GetKeyFrames()` returns {1-based index: frame_position}; the
+    frames are the VALUES, not the keys. Frames come back as floats.
+    """
+    try:
+        kfs = inp.GetKeyFrames()
+    except Exception:
+        return []
+    if not kfs:
+        return []
+    return sorted(float(frame) for frame in kfs.values())
+
+
+def _fusion_input_spline(inp):
+    """The modifier/spline tool driving `inp`, or None when it is not animated.
+
+    Keyframes do not live on the Input object -- they live on the spline
+    connected to it, which is what `add_keyframe` attaches via AddModifier.
+    """
+    try:
+        connected = inp.GetConnectedOutput()
+    except Exception:
+        return None
+    if connected is None:
+        return None
+    if not _has_method(connected, "GetTool"):
+        return None
+    try:
+        return connected.GetTool()
+    except Exception:
+        return None
+
+
+def _fusion_delete_keyframe(tool, p: Dict[str, Any]) -> Dict[str, Any]:
+    """Remove one keyframe from an animated Fusion input. (issue #155)
+
+    The original implementation called `inp.RemoveKeyFrame(time)`. No such
+    method exists on a Fusion Input, and the fusionscript bridge resolves an
+    unknown attribute to None rather than raising AttributeError -- so the
+    lookup succeeded silently and every call died at the callsite as an opaque
+    `'NoneType' object is not callable`. The action had never worked.
+
+    Deletion happens on the spline, reached the same way `add_keyframe`
+    created it, and every step that can be absent is checked before it is
+    called. The result is verified by reading the keyframe list back, because
+    a Fusion call returning without error is not proof it did anything.
+    """
+    tool_name = p["tool_name"]
+    input_name = p["input_name"]
+    inp = tool[input_name]
+    if not inp:
+        return _err(
+            f"Input '{input_name}' not found on tool '{tool_name}'",
+            code="FUSION_INPUT_NOT_FOUND", category="invalid_input",
+        )
+
+    try:
+        time = float(p["time"])
+    except (TypeError, ValueError):
+        return _err(
+            f"time must be a frame number, got {p['time']!r}",
+            code="INVALID_FRAME", category="invalid_input",
+        )
+
+    spline = _fusion_input_spline(inp)
+    if spline is None:
+        return _err(
+            f"Input '{input_name}' on tool '{tool_name}' is not animated, so it "
+            "has no keyframe to delete",
+            code="FUSION_INPUT_NOT_ANIMATED", category="precondition",
+            remediation="Use add_keyframe first; it attaches the spline that holds keyframes.",
+            state={"tool_name": tool_name, "input_name": input_name},
+        )
+
+    if not _has_method(spline, "DeleteKeyFrames"):
+        return _err(
+            f"The modifier on '{tool_name}.{input_name}' has no DeleteKeyFrames method",
+            code="FUSION_DELETE_KEYFRAMES_UNSUPPORTED", category="unsupported",
+            reason="Only spline modifiers (e.g. BezierSpline) support keyframe removal.",
+            state={"tool_name": tool_name, "input_name": input_name},
+        )
+
+    before = _fusion_keyframe_frames(inp)
+    if not any(abs(frame - time) < 1e-6 for frame in before):
+        return _err(
+            f"No keyframe at frame {time:g} on '{tool_name}.{input_name}'",
+            code="FUSION_KEYFRAME_NOT_FOUND", category="precondition",
+            state={"tool_name": tool_name, "input_name": input_name,
+                   "time": time, "keyframes": before},
+        )
+
+    try:
+        spline.DeleteKeyFrames(time)
+    except Exception as exc:
+        return _err(
+            f"DeleteKeyFrames({time:g}) raised: {exc}",
+            code="FUSION_DELETE_KEYFRAME_FAILED", category="resolve_api_failed",
+            state={"tool_name": tool_name, "input_name": input_name, "time": time},
+        )
+
+    after = _fusion_keyframe_frames(inp)
+    if any(abs(frame - time) < 1e-6 for frame in after):
+        return _err(
+            f"DeleteKeyFrames({time:g}) returned without error but the keyframe "
+            f"is still on '{tool_name}.{input_name}'",
+            code="FUSION_DELETE_KEYFRAME_NOOP", category="resolve_api_failed",
+            state={"tool_name": tool_name, "input_name": input_name,
+                   "time": time, "keyframes_before": before, "keyframes_after": after},
+        )
+
+    return _ok(time=time, remaining_keyframes=after)
+
+
 def _fusion_get_text_plus(comp, p: Dict[str, Any]) -> Dict[str, Any]:
     """Read the text of a Fusion Text+ tool / title template. (issue #73)"""
     tool, err = _fusion_find_text_tool(comp, p)
@@ -26624,7 +26742,9 @@ def fusion_comp(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[st
       get_attrs(tool_name) -> {attrs}
       add_keyframe(tool_name, input_name, time, value) -> {success}
       get_keyframes(tool_name, input_name) -> {keyframes}
-      delete_keyframe(tool_name, input_name, time) -> {success}
+      delete_keyframe(tool_name, input_name, time) -> {success, time, remaining_keyframes}
+        Deletes on the spline attached to the input. Structured errors when the
+        input is not animated or has no keyframe at that frame.
       get_comp_info() -> {name, tool_count, attrs}
       get_position(tool_name) -> {tool_name, x, y}  — read a node's FlowView position
       set_position(tool_name, x, y) -> {success, x, y, readback}  — move a node
@@ -26920,11 +27040,7 @@ def fusion_comp(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[st
             return _err(f"Tool '{p['tool_name']}' not found")
         comp.Lock()
         try:
-            inp = tool[p["input_name"]]
-            if not inp:
-                return _err(f"Input '{p['input_name']}' not found on tool '{p['tool_name']}'")
-            inp.RemoveKeyFrame(p["time"])
-            return _ok()
+            return _fusion_delete_keyframe(tool, p)
         finally:
             comp.Unlock()
 
@@ -27141,7 +27257,8 @@ def _validate_lua_syntax(source: str) -> Dict[str, Any]:
         f.write(source)
         tmp = f.name
     try:
-        result = subprocess.run([luac, "-p", tmp], capture_output=True, text=True, timeout=10,
+        result = subprocess.run([luac, "-p", tmp], capture_output=True, text=True,
+                                encoding="utf-8", errors="replace", timeout=10,
                                 stdin=subprocess.DEVNULL)
         if result.returncode == 0:
             return {"valid": True, "errors": None, "checker": luac}
@@ -27694,6 +27811,12 @@ def _python_env_for_resolve() -> Dict[str, str]:
     env = os.environ.copy()
     env["RESOLVE_SCRIPT_API"] = RESOLVE_API_PATH
     env["RESOLVE_SCRIPT_LIB"] = RESOLVE_LIB_PATH
+    # The child writes its stdout into a pipe, so Python picks the locale
+    # codepage rather than the console's — cp1252 on a default Windows install.
+    # A script that prints a non-Latin-1 character then dies with
+    # UnicodeEncodeError instead of returning its output, and the failure is
+    # attributed to the script rather than to the pipe it was handed (#153).
+    env["PYTHONIOENCODING"] = "utf-8"
     pp = env.get("PYTHONPATH", "")
     if RESOLVE_MODULES_PATH not in pp:
         env["PYTHONPATH"] = (RESOLVE_MODULES_PATH +
@@ -27741,7 +27864,8 @@ def _execute_python_script(path: str, args: List[str],
     cmd = [sys.executable, "-c", _PY_SCRIPT_EXIT_GUARD, path] + [str(a) for a in args]
     try:
         result = safe_run(cmd, env=_python_env_for_resolve(),
-                          capture_output=True, text=True, timeout=timeout)
+                          capture_output=True, text=True, encoding="utf-8",
+                          errors="replace", timeout=timeout)
     except subprocess.TimeoutExpired as e:
         return _err(f"Script timed out after {timeout}s. "
                     f"Partial stdout: {(e.stdout or '')[:1000]}")

package/src/utils/app_control.py

@@ -33,6 +33,8 @@ def _run_app_command(
             check=False,
             capture_output=True,
             text=True,
+            encoding="utf-8",
+            errors="replace",
             timeout=timeout,
         )
     except subprocess.TimeoutExpired:

package/src/utils/image_qc.py

@@ -189,7 +189,8 @@ def _probe_color_transfer(path: str) -> Optional[str]:
         "-show_entries", "stream=color_transfer", "-of", "default=nw=1:nk=1", path,
     ]
     try:
-        proc = subprocess.run(args, capture_output=True, text=True, timeout=30, check=False)
+        proc = subprocess.run(args, capture_output=True, text=True, encoding="utf-8",
+                              errors="replace", timeout=30, check=False)
     except (subprocess.TimeoutExpired, OSError):
         return None
     value = (proc.stdout or "").strip().lower()

package/src/utils/media_analysis.py

@@ -335,8 +335,20 @@ def _ensure_path_includes_standard_tool_dirs() -> None:
     /opt/homebrew/bin/ffprobe. Subprocess calls (subprocess.run(["ffprobe"...]))
     then also fail to find the binary. Prepending the standard tool dirs here
     fixes both detection and execution for every importer of this module.
+
+    The interpreter's own script directory is one of them, and it was missing.
+    A console script installed into the server's virtualenv — `pip install
+    openai-whisper` puts `whisper` in `venv/Scripts` on Windows, `venv/bin`
+    elsewhere — is only on PATH when that environment has been *activated*, and
+    nothing activates it: the client launches `venv/python server.py` directly.
+    So the tool was installed, working, and invisible, and `capabilities`
+    reported `whisper_cli.available: false` with no hint as to why (#153, where
+    the workaround that appeared to fix it was a shim placed on PATH by hand).
     """
     candidates = [
+        # The venv this server is running from, first: a tool installed
+        # deliberately alongside it should win over an older copy elsewhere.
+        os.path.dirname(os.path.abspath(sys.executable)),
         "/opt/homebrew/bin",
         "/opt/homebrew/sbin",
         "/usr/local/bin",

package/src/utils/resolve_bridge.py

@@ -216,7 +216,8 @@ def _process_name(pid: int) -> str:
 
         out = subprocess.run(
             ["ps", "-p", str(pid), "-o", "comm="],
-            capture_output=True, text=True, timeout=5, check=False,
+            capture_output=True, text=True, encoding="utf-8", errors="replace",
+            timeout=5, check=False,
         )
         return (out.stdout or "").strip()
     except Exception:  # pragma: no cover - defensive

package/src/utils/resolve_runtime.py

@@ -68,13 +68,23 @@ def _process_lines() -> Optional[List[str]]:
         if platform.system().lower() == "windows":
             # `tasklist` prints no command line, so the flag is invisible there.
             # WMIC does print it and is what makes headless detection possible.
+            #
+            # Decoded explicitly: `text=True` alone decodes with the locale
+            # codepage, which raises UnicodeDecodeError on a byte cp1252 has no
+            # mapping for — and this read is the input to the second-instance
+            # guard, so it must fail to "cannot tell", never to an exception.
+            # ASCII is byte-identical under both codecs, so the matching this
+            # feeds is unchanged; what WMIC emits for a non-ASCII install path
+            # on a non-English Windows is not something we can verify here.
             out = subprocess.run(
                 ["wmic", "process", "where", "name='Resolve.exe'", "get", "CommandLine"],
-                capture_output=True, text=True, timeout=10, check=False,
+                capture_output=True, text=True, encoding="utf-8", errors="replace",
+                timeout=10, check=False,
             )
         else:
             out = subprocess.run(
-                ["ps", "-Ao", "command="], capture_output=True, text=True, timeout=10, check=False
+                ["ps", "-Ao", "command="], capture_output=True, text=True,
+                encoding="utf-8", errors="replace", timeout=10, check=False,
             )
         if out.returncode != 0 and not out.stdout:
             return None