@hybridlabor-api/aos 4.2.0 → 4.4.0

package/mcps/davinci-resolve-mcp/tests/test-after-restart.bat

@@ -1,83 +0,0 @@
-@echo off
-:: Restart DaVinci Resolve MCP Server and run tests
-:: This script combines server restart with automated testing
-
-echo ========================================================
-echo DaVinci Resolve MCP Server - Test After Restart
-echo ========================================================
-
-:: Change to the directory where the script is located
-cd /d "%~dp0"
-
-:: Check if DaVinci Resolve is running
-tasklist | findstr "Resolve" > nul
-if %ERRORLEVEL% NEQ 0 (
-    echo [33m⚠️ DaVinci Resolve is not running. Please start it before continuing.[0m
-    set /p continue_anyway=Start testing anyway? (y/n): 
-    if /i not "%continue_anyway%"=="y" (
-        echo Aborting test.
-        exit /b 1
-    )
-    echo Continuing with testing despite DaVinci Resolve not running...
-)
-
-:: Step 1: Restart the server using the restart script
-echo.
-echo Step 1: Restarting DaVinci Resolve MCP Server...
-if exist restart-server.bat (
-    call restart-server.bat
-    
-    :: Check if restart was successful
-    timeout /t 3 /nobreak > nul
-    wmic process where "commandline like '%%python%%resolve_mcp_server.py%%'" get processid 2>nul | findstr /r "[0-9]" > nul
-    if %ERRORLEVEL% EQU 0 (
-        echo [32m✅ Server restart successful[0m
-    ) else (
-        echo [31m❌ Server restart failed. Please check server logs for errors.[0m
-        exit /b 1
-    )
-) else (
-    echo [31m❌ restart-server.bat not found. Cannot restart server.[0m
-    exit /b 1
-)
-
-:: Step 2: Create test timeline (optional)
-echo.
-echo Step 2: Create test timeline with media?
-set /p create_timeline=Create test timeline? (y/n): 
-if /i "%create_timeline%"=="y" (
-    echo Creating test timeline...
-    if exist create_test_timeline.py (
-        python create_test_timeline.py
-        if %ERRORLEVEL% NEQ 0 (
-            echo [33m⚠️ Test timeline creation had issues, but we'll continue with testing.[0m
-        )
-    ) else (
-        echo [31m❌ create_test_timeline.py not found. Skipping test timeline creation.[0m
-    )
-) else (
-    echo Skipping test timeline creation.
-)
-
-:: Step 3: Run automated tests
-echo.
-echo Step 3: Running automated tests...
-if exist test_improvements.py (
-    python test_improvements.py
-    set TEST_RESULT=%ERRORLEVEL%
-    if %TEST_RESULT% EQU 0 (
-        echo [32m✅ All tests passed![0m
-    ) else (
-        echo [33m⚠️ Some tests failed. Check the logs for details.[0m
-    )
-) else (
-    echo [31m❌ test_improvements.py not found. Cannot run tests.[0m
-    exit /b 1
-)
-
-echo.
-echo ========================================================
-echo Testing complete. Results logged to mcp_test_results.log
-echo ========================================================
-
-exit /b %TEST_RESULT% 

package/mcps/davinci-resolve-mcp/tests/test-after-restart.sh

@@ -1,87 +0,0 @@
-#!/bin/bash
-# Restart DaVinci Resolve MCP Server and run tests
-# This script combines server restart with automated testing
-
-echo "========================================================"
-echo "DaVinci Resolve MCP Server - Test After Restart"
-echo "========================================================"
-
-# Get the directory where the script is located
-SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-cd "$SCRIPT_DIR"
-
-# Check if DaVinci Resolve is running
-check_resolve_running() {
-    ps -ef | grep -i "[D]aVinci Resolve" > /dev/null
-    return $?
-}
-
-if ! check_resolve_running; then
-    echo "⚠️ DaVinci Resolve is not running. Please start it before continuing."
-    read -p "Start testing anyway? (y/n): " continue_anyway
-    if [[ "$continue_anyway" != "y" ]]; then
-        echo "Aborting test."
-        exit 1
-    fi
-    echo "Continuing with testing despite DaVinci Resolve not running..."
-fi
-
-# Step 1: Restart the server using the restart script
-echo "Step 1: Restarting DaVinci Resolve MCP Server..."
-if [ -f "./restart-server.sh" ]; then
-    ./restart-server.sh
-    
-    # Check if restart was successful
-    sleep 3
-    pgrep -f "python.*resolve_mcp_server.py" > /dev/null
-    if [ $? -eq 0 ]; then
-        echo "✅ Server restart successful"
-    else
-        echo "❌ Server restart failed. Please check server logs for errors."
-        exit 1
-    fi
-else
-    echo "❌ restart-server.sh not found. Cannot restart server."
-    exit 1
-fi
-
-# Step 2: Create test timeline (optional)
-echo
-echo "Step 2: Create test timeline with media?"
-read -p "Create test timeline? (y/n): " create_timeline
-if [[ "$create_timeline" == "y" ]]; then
-    echo "Creating test timeline..."
-    if [ -f "./create_test_timeline.py" ]; then
-        python3 ./create_test_timeline.py
-        if [ $? -ne 0 ]; then
-            echo "⚠️ Test timeline creation had issues, but we'll continue with testing."
-        fi
-    else
-        echo "❌ create_test_timeline.py not found. Skipping test timeline creation."
-    fi
-else
-    echo "Skipping test timeline creation."
-fi
-
-# Step 3: Run automated tests
-echo
-echo "Step 3: Running automated tests..."
-if [ -f "./test_improvements.py" ]; then
-    python3 ./test_improvements.py
-    TEST_RESULT=$?
-    if [ $TEST_RESULT -eq 0 ]; then
-        echo "✅ All tests passed!"
-    else
-        echo "⚠️ Some tests failed. Check the logs for details."
-    fi
-else
-    echo "❌ test_improvements.py not found. Cannot run tests."
-    exit 1
-fi
-
-echo
-echo "========================================================"
-echo "Testing complete. Results logged to mcp_test_results.log"
-echo "========================================================"
-
-exit $TEST_RESULT 

package/mcps/davinci-resolve-mcp/tests/test_action_help.py

@@ -1,47 +0,0 @@
-"""Contract tests for B4 — action_help pull-on-demand action guidance.
-
-See local/design/agentic-flow-improvements-gameplan.md §3 task B4.
-"""
-import unittest
-
-import src.server as compound
-
-
-class ActionHelpTest(unittest.TestCase):
-    def test_known_action_returns_summary_params_returns_example(self):
-        out = compound._action_help("timeline_item_color", {"name": "safe_set_cdl"})
-        self.assertTrue(out.get("success"))
-        self.assertEqual(out["action"], "safe_set_cdl")
-        self.assertIn("summary", out)
-        self.assertIn("params", out)
-        self.assertIn("returns", out)
-        self.assertIn("example", out)
-        # Example block is callable-syntax — at minimum it contains the action name.
-        self.assertIn("safe_set_cdl", out["example"])
-
-    def test_unknown_action_returns_structured_error(self):
-        out = compound._action_help("timeline_item_color", {"name": "no_such_action"})
-        self.assertIn("error", out)
-        self.assertEqual(out["error"]["code"], "HELP_NOT_REGISTERED")
-        self.assertEqual(out["error"]["category"], "invalid_input")
-
-    def test_no_name_lists_available(self):
-        out = compound._action_help("timeline_item_color", {})
-        self.assertIn("available", out)
-        self.assertIn("safe_set_cdl", out["available"])
-        self.assertIn("safe_apply_drx", out["available"])
-        self.assertIn("grade_evidence_base", out["available"])
-
-    def test_each_registered_tool_has_at_least_one_action(self):
-        for tool_name, catalog in compound._ACTION_HELP.items():
-            self.assertGreater(len(catalog), 0, f"empty catalog for {tool_name}")
-
-    def test_dispatch_works_through_timeline_item_color(self):
-        # Calling action_help should not require a current timeline/item.
-        out = compound.timeline_item_color("action_help", {"name": "safe_apply_drx"})
-        self.assertTrue(out.get("success"), out)
-        self.assertEqual(out["action"], "safe_apply_drx")
-
-
-if __name__ == "__main__":
-    unittest.main()

package/mcps/davinci-resolve-mcp/tests/test_action_list_drift.py

@@ -1,163 +0,0 @@
-"""Static guard: each tool's _unknown(action, [...]) list matches its dispatch.
-
-The valid-actions list in the unknown-action error is what agents read to
-recover from a typo, and what tooling parses for discovery. When it drifts
-from the real elif chain, implemented actions become invisible (clip_where
-and action_help were missing from three tools' lists before this guard) or
-phantom actions get advertised.
-
-Checked both directions per tool:
-  - every action compared against `action` in the function body must appear
-    in the _unknown list (unless it is a documented alias in ALIASES)
-  - every listed action must be implemented
-"""
-from __future__ import annotations
-
-import ast
-import pathlib
-import unittest
-
-SERVER = pathlib.Path(__file__).resolve().parent.parent / "src" / "server.py"
-
-# Intentional aliases: accepted by dispatch but advertised under their
-# canonical name only.
-ALIASES = {
-    "setup": {"capabilities", "options", "get", "status", "set", "configure", "clear", "reset"},
-}
-
-
-def _module_list_constants(tree):
-    consts = {}
-    for node in tree.body:
-        if isinstance(node, ast.Assign) and len(node.targets) == 1 and isinstance(node.targets[0], ast.Name):
-            if isinstance(node.value, (ast.List, ast.Tuple)):
-                values = [
-                    elt.value
-                    for elt in node.value.elts
-                    if isinstance(elt, ast.Constant) and isinstance(elt.value, str)
-                ]
-                if len(values) == len(node.value.elts):
-                    consts[node.targets[0].id] = values
-    return consts
-
-
-def _implemented_actions(fn):
-    found = set()
-    for node in ast.walk(fn):
-        if isinstance(node, ast.Compare) and isinstance(node.left, ast.Name) and node.left.id == "action":
-            for comp in node.comparators:
-                if isinstance(comp, ast.Constant) and isinstance(comp.value, str):
-                    found.add(comp.value)
-                elif isinstance(comp, (ast.Set, ast.List, ast.Tuple)):
-                    found.update(
-                        elt.value
-                        for elt in comp.elts
-                        if isinstance(elt, ast.Constant) and isinstance(elt.value, str)
-                    )
-    return found
-
-
-def _listed_actions(fn, consts):
-    for node in ast.walk(fn):
-        if isinstance(node, ast.Call) and isinstance(node.func, ast.Name) and node.func.id == "_unknown":
-            if len(node.args) >= 2 and isinstance(node.args[1], ast.List):
-                listed, resolvable = set(), True
-                for elt in node.args[1].elts:
-                    if isinstance(elt, ast.Constant) and isinstance(elt.value, str):
-                        listed.add(elt.value)
-                    elif isinstance(elt, ast.Starred) and isinstance(elt.value, ast.Name) and elt.value.id in consts:
-                        listed.update(consts[elt.value.id])
-                    else:
-                        resolvable = False
-                return listed, resolvable
-    return None, False
-
-
-class ActionListDriftTest(unittest.TestCase):
-    def test_unknown_action_lists_match_dispatch(self):
-        tree = ast.parse(SERVER.read_text())
-        consts = _module_list_constants(tree)
-        problems = []
-        checked = 0
-        for node in tree.body:
-            # Async tools (e.g. media_analysis) drifted unchecked for several
-            # releases because only FunctionDef was inspected.
-            if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-                continue
-            listed, resolvable = _listed_actions(node, consts)
-            if listed is None or not resolvable:
-                continue
-            implemented = _implemented_actions(node)
-            if not implemented:
-                continue
-            checked += 1
-            aliases = ALIASES.get(node.name, set())
-            missing = sorted(implemented - listed - aliases)
-            phantom = sorted(listed - implemented)
-            if missing:
-                problems.append(f"{node.name}: implemented but not listed: {missing}")
-            if phantom:
-                problems.append(f"{node.name}: listed but not implemented: {phantom}")
-        self.assertGreater(checked, 10, "drift checker found too few tools — parser broken?")
-        self.assertEqual(problems, [], "\n".join(problems))
-
-    def test_no_unreachable_actions_inside_membership_blocks(self):
-        """An `action == "x"` check nested under `if action in {...}` is dead
-        code unless "x" is in the membership set. The V2 correction actions
-        (update_shot_field et al.) were unreachable from v2.24.0 to v2.40.0
-        because of exactly this — the panel proxied to the helpers directly,
-        which masked it. Guard the whole class.
-        """
-        tree = ast.parse(SERVER.read_text())
-        problems = []
-
-        def membership_set(test):
-            # Matches: action in {...} / [...] / (...) with string constants.
-            if (
-                isinstance(test, ast.Compare)
-                and isinstance(test.left, ast.Name)
-                and test.left.id == "action"
-                and len(test.ops) == 1
-                and isinstance(test.ops[0], ast.In)
-                and isinstance(test.comparators[0], (ast.Set, ast.List, ast.Tuple))
-            ):
-                elts = test.comparators[0].elts
-                values = {
-                    elt.value
-                    for elt in elts
-                    if isinstance(elt, ast.Constant) and isinstance(elt.value, str)
-                }
-                if len(values) == len(elts):
-                    return values
-            return None
-
-        for fn in ast.walk(tree):
-            if not isinstance(fn, (ast.FunctionDef, ast.AsyncFunctionDef)):
-                continue
-            for node in ast.walk(fn):
-                if not isinstance(node, ast.If):
-                    continue
-                allowed = membership_set(node.test)
-                if allowed is None:
-                    continue
-                for inner in ast.walk(ast.Module(body=node.body, type_ignores=[])):
-                    if (
-                        isinstance(inner, ast.Compare)
-                        and isinstance(inner.left, ast.Name)
-                        and inner.left.id == "action"
-                        and len(inner.ops) == 1
-                        and isinstance(inner.ops[0], ast.Eq)
-                        and isinstance(inner.comparators[0], ast.Constant)
-                        and isinstance(inner.comparators[0].value, str)
-                    ):
-                        value = inner.comparators[0].value
-                        if value not in allowed:
-                            problems.append(
-                                f"{fn.name}: action == {value!r} at line {inner.lineno} is "
-                                f"unreachable — not in the enclosing membership set"
-                            )
-        self.assertEqual(problems, [], "\n".join(problems))
-
-
-if __name__ == "__main__":
-    unittest.main()

package/mcps/davinci-resolve-mcp/tests/test_ai_console_dispatch.py

@@ -1,91 +0,0 @@
-"""Tests for the AI Console op dispatcher (_run_resolve_ai_op).
-
-The dispatcher routes a {op, target, params} request from the control panel to
-the right consolidated server tool. We patch the server tools so no live Resolve
-is needed and assert the routing + params relaying (including the confirm-token
-pass-through for the media-creating ops).
-"""
-import unittest
-
-import src.server as server
-import src.analysis_dashboard as dash
-
-
-class AiConsoleDispatchTest(unittest.TestCase):
-    def setUp(self):
-        self.calls = []
-        self._orig = {
-            "folder": server.folder,
-            "media_pool_item": server.media_pool_item,
-            "project_settings": server.project_settings,
-            "resolve_control": server.resolve_control,
-        }
-
-        def rec(name):
-            def _fn(action, params=None):
-                self.calls.append((name, action, params or {}))
-                return {"success": True, "tool": name, "action": action, "params": params or {}}
-            return _fn
-
-        server.folder = rec("folder")
-        server.media_pool_item = rec("media_pool_item")
-        server.project_settings = rec("project_settings")
-        server.resolve_control = rec("resolve_control")
-
-    def tearDown(self):
-        for name, fn in self._orig.items():
-            setattr(server, name, fn)
-
-    def test_folder_target_routes_to_folder_tool(self):
-        out = dash._run_resolve_ai_op({"op": "analyze_for_slate", "target": "folder",
-                                       "params": {"marker_color": "Sky"}})
-        self.assertTrue(out["success"])
-        self.assertEqual(self.calls[0][0], "folder")
-        self.assertEqual(self.calls[0][1], "analyze_for_slate")
-        self.assertEqual(self.calls[0][2]["marker_color"], "Sky")
-
-    def test_clip_target_routes_to_media_pool_item(self):
-        out = dash._run_resolve_ai_op({"op": "perform_audio_classification", "target": "clip",
-                                       "params": {"clip_id": "c1"}})
-        self.assertTrue(out["success"])
-        self.assertEqual(self.calls[0][0], "media_pool_item")
-        self.assertEqual(self.calls[0][2]["clip_id"], "c1")
-
-    def test_clip_target_without_id_errors(self):
-        out = dash._run_resolve_ai_op({"op": "analyze_for_slate", "target": "clip", "params": {}})
-        self.assertFalse(out["success"])
-        self.assertIn("clip_id", out["error"])
-        self.assertEqual(self.calls, [])
-
-    def test_generate_speech_routes_to_project_settings(self):
-        out = dash._run_resolve_ai_op({"op": "generate_speech",
-                                       "params": {"speech_generation_settings": {"TextInput": "hi"}}})
-        self.assertTrue(out["success"])
-        self.assertEqual(self.calls[0][0], "project_settings")
-        self.assertEqual(self.calls[0][1], "generate_speech")
-
-    def test_disable_background_tasks_routes_to_resolve_control(self):
-        out = dash._run_resolve_ai_op({"op": "disable_background_tasks"})
-        self.assertTrue(out["success"])
-        self.assertEqual(self.calls[0][0], "resolve_control")
-        self.assertEqual(self.calls[0][1], "disable_background_tasks_for_current_session")
-
-    def test_confirm_token_passed_through(self):
-        dash._run_resolve_ai_op({"op": "remove_motion_blur", "target": "folder",
-                                 "params": {"deblur_option": {}, "confirm_token": "tok123"}})
-        self.assertEqual(self.calls[0][2]["confirm_token"], "tok123")
-
-    def test_unknown_op_errors(self):
-        out = dash._run_resolve_ai_op({"op": "frobnicate"})
-        self.assertFalse(out["success"])
-        self.assertIn("unknown op", out["error"])
-        self.assertEqual(self.calls, [])
-
-    def test_missing_op_errors(self):
-        out = dash._run_resolve_ai_op({})
-        self.assertFalse(out["success"])
-        self.assertEqual(self.calls, [])
-
-
-if __name__ == "__main__":
-    unittest.main()

package/mcps/davinci-resolve-mcp/tests/test_analysis_caps.py

@@ -1,210 +0,0 @@
-"""Unit tests for src/utils/analysis_caps.py."""
-
-from __future__ import annotations
-
-import json
-import os
-import shutil
-import tempfile
-import time
-import unittest
-
-from src.utils import analysis_caps, timeline_brain_db
-
-
-class PresetResolution(unittest.TestCase):
-    def test_known_presets_resolve(self) -> None:
-        for name in analysis_caps.VALID_PRESETS:
-            caps = analysis_caps.resolve_caps(name)
-            self.assertEqual(caps.preset, name)
-
-    def test_unknown_preset_falls_back_to_standard(self) -> None:
-        caps = analysis_caps.resolve_caps("nope")
-        self.assertEqual(caps.preset, analysis_caps.DEFAULT_PRESET)
-
-    def test_unlimited_has_all_none(self) -> None:
-        caps = analysis_caps.resolve_caps(analysis_caps.PRESET_UNLIMITED)
-        for field in ("response_chars", "vision_tokens_per_clip", "frames_per_clip",
-                      "vision_tokens_per_job", "vision_tokens_per_day",
-                      "wall_clock_seconds_per_call", "max_frame_dim_pixels"):
-            self.assertIsNone(getattr(caps, field), msg=f"{field} should be uncapped")
-
-    def test_overrides_replace_specific_fields(self) -> None:
-        caps = analysis_caps.resolve_caps(
-            analysis_caps.PRESET_STANDARD,
-            {"vision_tokens_per_clip": 12345, "max_frame_dim_pixels": 256},
-        )
-        self.assertEqual(caps.vision_tokens_per_clip, 12345)
-        self.assertEqual(caps.max_frame_dim_pixels, 256)
-        # Other fields untouched.
-        self.assertEqual(caps.frames_per_clip, 80)
-
-    def test_unlimited_string_override_lifts_cap(self) -> None:
-        caps = analysis_caps.resolve_caps(
-            analysis_caps.PRESET_MINIMAL,
-            {"vision_tokens_per_day": "unlimited"},
-        )
-        self.assertIsNone(caps.vision_tokens_per_day)
-
-    def test_unknown_override_key_ignored(self) -> None:
-        caps = analysis_caps.resolve_caps(
-            analysis_caps.PRESET_STANDARD, {"frobnicate": 99},
-        )
-        # Should silently return the base preset.
-        self.assertEqual(caps, analysis_caps.CAP_PRESETS[analysis_caps.PRESET_STANDARD])
-
-    def test_list_presets_returns_all(self) -> None:
-        presets = analysis_caps.list_presets()
-        self.assertEqual(set(presets), analysis_caps.VALID_PRESETS)
-        # Every preset includes the 7 cap dimensions + preset name.
-        for name, body in presets.items():
-            self.assertEqual(body["preset"], name)
-            for field in ("response_chars", "frames_per_clip", "max_frame_dim_pixels"):
-                self.assertIn(field, body)
-
-
-class BudgetEnforcement(unittest.TestCase):
-    def setUp(self) -> None:
-        self.tmp = tempfile.mkdtemp(prefix="caps_budget_test_")
-        self.project_root = os.path.join(self.tmp, "project")
-        os.makedirs(self.project_root, exist_ok=True)
-
-    def tearDown(self) -> None:
-        timeline_brain_db.reset_for_test(self.project_root)
-        shutil.rmtree(self.tmp, ignore_errors=True)
-
-    def test_fresh_db_has_zero_usage(self) -> None:
-        caps = analysis_caps.resolve_caps(analysis_caps.PRESET_STANDARD)
-        decision = analysis_caps.check_budget(
-            project_root=self.project_root, caps=caps,
-            estimated_vision_tokens=1000, clip_id="c1",
-        )
-        self.assertTrue(decision.allowed)
-        self.assertEqual(decision.current_usage["clip_vision_tokens"], 0)
-
-    def test_unlimited_preset_always_allows(self) -> None:
-        caps = analysis_caps.resolve_caps(analysis_caps.PRESET_UNLIMITED)
-        # Pretend we've already spent a million tokens on this clip.
-        analysis_caps.record_usage(
-            project_root=self.project_root, scope=analysis_caps.SCOPE_CLIP,
-            scope_key="c1", vision_tokens=10_000_000,
-        )
-        decision = analysis_caps.check_budget(
-            project_root=self.project_root, caps=caps,
-            estimated_vision_tokens=10_000_000, clip_id="c1",
-        )
-        self.assertTrue(decision.allowed)
-
-    def test_per_clip_cap_blocks_when_exceeded(self) -> None:
-        caps = analysis_caps.resolve_caps(analysis_caps.PRESET_MINIMAL)
-        # minimal.vision_tokens_per_clip = 16000.
-        analysis_caps.record_usage(
-            project_root=self.project_root, scope=analysis_caps.SCOPE_CLIP,
-            scope_key="c1", vision_tokens=15_500,
-        )
-        # Need 1000 more, only 500 left.
-        decision = analysis_caps.check_budget(
-            project_root=self.project_root, caps=caps,
-            estimated_vision_tokens=1000, clip_id="c1",
-        )
-        self.assertFalse(decision.allowed)
-        self.assertEqual(decision.reason, "over_clip_cap")
-        self.assertEqual(decision.headroom["clip"], 500)
-
-    def test_per_day_cap_blocks_when_exceeded(self) -> None:
-        caps = analysis_caps.resolve_caps(analysis_caps.PRESET_MINIMAL)
-        # minimal.vision_tokens_per_day = 150_000. Spend 149k under DAY scope.
-        analysis_caps.record_usage(
-            project_root=self.project_root, scope=analysis_caps.SCOPE_DAY,
-            scope_key=None, vision_tokens=149_000,
-        )
-        # Try to spend 2k — would push to 151k (over day). Pass no clip_id so the
-        # check doesn't trip the smaller clip cap first.
-        decision = analysis_caps.check_budget(
-            project_root=self.project_root, caps=caps,
-            estimated_vision_tokens=2_000,
-        )
-        self.assertFalse(decision.allowed)
-        self.assertEqual(decision.reason, "over_day_cap")
-
-    def test_record_usage_all_scopes_writes_multiple_rows(self) -> None:
-        result = analysis_caps.record_usage_all_scopes(
-            project_root=self.project_root,
-            clip_id="c1", job_id="j1",
-            vision_tokens=1234, frames_uploaded=8,
-        )
-        self.assertEqual(len(result["rows"]), 3)
-        conn = timeline_brain_db.connect(self.project_root)
-        scopes = conn.execute(
-            "SELECT scope FROM analysis_token_usage ORDER BY scope"
-        ).fetchall()
-        self.assertEqual(sorted({r["scope"] for r in scopes}), ["clip", "day", "job"])
-
-    def test_usage_rollup_percent_consumed(self) -> None:
-        caps = analysis_caps.resolve_caps(analysis_caps.PRESET_MINIMAL)
-        analysis_caps.record_usage(
-            project_root=self.project_root, scope=analysis_caps.SCOPE_DAY,
-            scope_key=None, vision_tokens=75_000,
-        )
-        rollup = analysis_caps.get_usage_rollup(
-            project_root=self.project_root, caps=caps,
-        )
-        # 75000 / 150000 = 50% (minimal.vision_tokens_per_day = 150_000)
-        self.assertAlmostEqual(rollup["percent_consumed"]["day"], 50.0)
-
-
-class ResponseTrimming(unittest.TestCase):
-    def test_under_cap_returns_unchanged(self) -> None:
-        payload = {"a": 1, "b": "small"}
-        out = analysis_caps.trim_response_payload(payload, max_chars=10_000)
-        self.assertIs(out, payload)
-
-    def test_uncapped_returns_unchanged(self) -> None:
-        payload = {"x": "y" * 100_000}
-        self.assertIs(analysis_caps.trim_response_payload(payload, None), payload)
-
-    def test_trims_large_list_fields_first(self) -> None:
-        payload = {
-            "summary": "concise",
-            "transcript_segments": [{"text": "blah"} for _ in range(500)],
-        }
-        out = analysis_caps.trim_response_payload(payload, max_chars=2000)
-        self.assertIn("_trimmed", out)
-        # Should have trimmed transcript_segments.
-        self.assertTrue(len(out["transcript_segments"]) <= 5)
-        # And serialised result fits.
-        self.assertLessEqual(len(json.dumps(out, default=str)), 2000)
-
-    def test_falls_back_to_string_truncation(self) -> None:
-        payload = {"single_field": "x" * 50_000}
-        out = analysis_caps.trim_response_payload(payload, max_chars=1000)
-        if isinstance(out, str):
-            self.assertLessEqual(len(out), 1000)
-        else:
-            self.assertLessEqual(len(json.dumps(out, default=str)), 1000)
-
-
-class WallClockTimeout(unittest.TestCase):
-    def test_fast_call_returns(self) -> None:
-        result = analysis_caps.run_with_timeout(lambda: 42, 5)
-        self.assertEqual(result, 42)
-
-    def test_slow_call_raises(self) -> None:
-        # 100ms timeout against a 500ms sleep → should fire.
-        with self.assertRaises(analysis_caps.WallClockTimeout):
-            analysis_caps.run_with_timeout(lambda: time.sleep(0.5), 0.1)
-
-    def test_timeout_disabled_passthrough(self) -> None:
-        # None and 0 both disable.
-        self.assertEqual(analysis_caps.run_with_timeout(lambda x: x * 2, None, 21), 42)
-        self.assertEqual(analysis_caps.run_with_timeout(lambda x: x * 2, 0, 21), 42)
-
-    def test_function_args_kwargs_passthrough(self) -> None:
-        result = analysis_caps.run_with_timeout(
-            lambda a, b=0: a + b, 2, 10, b=32,
-        )
-        self.assertEqual(result, 42)
-
-
-if __name__ == "__main__":
-    unittest.main()