diff --git a/odev/_version.py b/odev/_version.py
index 12102f76..3273ca43 100644
--- a/odev/_version.py
+++ b/odev/_version.py
@@ -22,4 +22,4 @@
 # or merged change.
 # ------------------------------------------------------------------------------
 
-__version__ = "4.29.2"
+__version__ = "4.29.3"
diff --git a/odev/commands/database/create.py b/odev/commands/database/create.py
index 684aa9fd..57432319 100644
--- a/odev/commands/database/create.py
+++ b/odev/commands/database/create.py
@@ -9,7 +9,6 @@
 from odev.common.databases import LocalDatabase
 from odev.common.errors.odev import OdevError
 from odev.common.odev import logger
-from odev.common.odoobin import OdoobinProcess
 from odev.common.version import OdooVersion
 
 
@@ -176,14 +175,14 @@ def initialize_database(self) -> None:
         if not re.search(r"--st(op-after-init)?", joined_args):
             args.append("--stop-after-init")
 
-        process = self.odoobin or OdoobinProcess(self._database)
+        process = self.odoobin or self.odev.odoobin_process_class(self._database)
         process.with_edition("enterprise" if self.args.enterprise else "community")
         process.with_version(self.version)
         process.with_venv(self.venv)
         process.with_worktree(self.worktree)
 
         try:
-            run_process = process.run(args=args, progress=self.odoobin_progress, prepare=True)
+            run_process = process.run(args=args, stream_filter=self.odoobin_progress, prepare=True)
             self.console.print()
         except OdevError as error:
             logger.error(str(error))
diff --git a/odev/commands/database/deploy.py b/odev/commands/database/deploy.py
index 9e96af41..925135e7 100644
--- a/odev/commands/database/deploy.py
+++ b/odev/commands/database/deploy.py
@@ -32,7 +32,7 @@ def run(self):
         odoobin: OdoobinProcess = (
             self._database.process
             if isinstance(self._database, LocalDatabase)
-            else OdoobinProcess(LocalDatabase(self.odev.name), version=self._database.version)
+            else self.odev.odoobin_process_class(LocalDatabase(self.odev.name), version=self._database.version)
         )
 
         url = self._database.url if isinstance(self._database, RemoteDatabase) else None
diff --git a/odev/commands/database/run.py b/odev/commands/database/run.py
index 3ae8a81d..a0b54ace 100644
--- a/odev/commands/database/run.py
+++ b/odev/commands/database/run.py
@@ -76,7 +76,7 @@ def run(self):
         if self.odoobin.is_running:
             raise self.error(f"Database {self._database.name!r} is already running")
 
-        process = self.odoobin.run(args=self.args.odoo_args, progress=self.odoobin_progress)
+        process = self.odoobin.run(args=self.args.odoo_args, stream_filter=self.odoobin_progress)
 
         if process and process.returncode:
             raise self.error("Odoo process failed")
diff --git a/odev/commands/database/test.py b/odev/commands/database/test.py
index b5270b36..afb3057f 100644
--- a/odev/commands/database/test.py
+++ b/odev/commands/database/test.py
@@ -123,7 +123,7 @@ def run_test_database(self):
         if not self.test_database.exists:
             self.create_test_database()
 
-        odoobin = self.test_database.process or OdoobinProcess(self.test_database)
+        odoobin = self.test_database.process or self.odev.odoobin_process_class(self.test_database)
         odoobin.with_version(self.version)
 
         edition = (
@@ -138,7 +138,7 @@ def run_test_database(self):
         odoobin.additional_addons_paths = cast(OdoobinProcess, self.odoobin).additional_addons_paths
 
         try:
-            process = odoobin.run(args=args, progress=self.odoobin_progress)
+            process = odoobin.run(args=args, stream_filter=self.odoobin_progress)
 
             if process is not None and process.returncode != 0 and not self.test_buffer:
                 raise self.error("Odoo crashed during initialization. Check the logs above.")
diff --git a/odev/commands/database/upgrade_code.py b/odev/commands/database/upgrade_code.py
index f4ebb60e..61f7e39f 100644
--- a/odev/commands/database/upgrade_code.py
+++ b/odev/commands/database/upgrade_code.py
@@ -116,7 +116,7 @@ def run(self):
             self.odoobin.odoobin_path,
             cmd_args,
             stream=True,
-            progress=lambda line: self.odoobin.console.print(line, end=""),
+            stream_filter=lambda line: (self.odoobin.console.print(line, end=""), line)[1],
         )
         if result.returncode not in (0, 1):
             raise self.error(f"Odoo exited with code {result.returncode}")
diff --git a/odev/common/commands/base.py b/odev/common/commands/base.py
index 3c56b517..e85c20b2 100644
--- a/odev/common/commands/base.py
+++ b/odev/common/commands/base.py
@@ -300,12 +300,12 @@ def _rescue_positional_from_unknown_flag(
             if captured is None:
                 continue
 
-            raw_val = (
-                captured[0]
-                if isinstance(captured, list) and captured
-                else (str(captured) if not isinstance(captured, list) else None)
-            )
-            if raw_val is None:
+            if isinstance(captured, list):
+                raw_val = ",".join(map(str, captured))
+            else:
+                raw_val = str(captured)
+
+            if not raw_val:
                 continue
 
             try:
diff --git a/odev/common/commands/odoobin.py b/odev/common/commands/odoobin.py
index 4b2256e4..a6088f56 100644
--- a/odev/common/commands/odoobin.py
+++ b/odev/common/commands/odoobin.py
@@ -83,41 +83,6 @@ class OdoobinCommand(LocalDatabaseCommand, ABC):
     # Properties
     # --------------------------------------------------------------------------
 
-    ODOO_LOG_REGEX: re.Pattern = re.compile(
-        r"""
-            (?:
-                ((?P<date>\d{4}-\d{2}-\d{2})\s)?
-                (?P<time>\d{2}:\d{2}:\d{2},\d{3})\s
-                ((?P<pid>\d+)\s)?
-                (?P<level>[A-Z]+)\s
-                (?P<database>[^\s]+)\s
-                (?P<logger>
-                    ((?:odoo\.addons\.)(?P<module>[^\.]+))?[^:]+
-                ):\s
-                (?P<description>.*)
-            )
-        """,
-        re.VERBOSE | re.IGNORECASE,
-    )
-    """Regular expression to match the output of odoo-bin."""
-
-    ODOO_LOG_WERKZEUG_REGEX: re.Pattern = re.compile(
-        r"""
-            (?:
-                (?P<ip>(?:\d{1,3}\.){3}\d{1,3}).+?\]\s\"
-                (?P<verb>\w+)\s
-                (?P<url>.+?(?=\s))\s
-                (?P<http>.+?(?=\"))\"\s
-                (?P<code>\d+)\s-\s
-                (?P<count_query>\d+)\s
-                (?P<time_query>[\d\.]+)\s
-                (?P<time_remaining>[\d\.]+)
-            )
-        """,
-        re.VERBOSE | re.IGNORECASE,
-    )
-    """Regular expression to match the output of odoo-bin Werkzeug-specific logs."""
-
     last_level: str = "INFO"
     """Log-level level of the last line printed by the odoo-bin process."""
 
@@ -180,16 +145,17 @@ def combined_odoo_args(self) -> list[str]:
             args.insert(0, ",".join(self.args.addons))
         return args
 
-    def odoobin_progress(self, line: str):
+    def odoobin_progress(self, line: str) -> str | None:
         """Beautify odoo logs on the fly."""
         match = self._parse_progress_log_line(line)
 
         if match is None or not self.args.pretty:
             self.print(markup.escape(line), highlight=False, soft_wrap=False)
-            return
+            return line
 
         self.last_level = match.group("level").lower()
         self._print_progress_log_line(match)
+        return line
 
     def _guess_addons_paths(self) -> list[Path]:
         """Guess the addons path."""
@@ -249,7 +215,7 @@ def _set_odoobin_process(self, force=False) -> None:
         edition: Literal["community", "enterprise"] = (
             "enterprise" if self.args.enterprise or self._database.edition == "enterprise" else "community"
         )
-        process = OdoobinProcess(
+        process = self.odev.odoobin_process_class(
             database=self._database,
             version=version,
             venv=venv.name,
@@ -264,7 +230,7 @@ def _print_progress_log_line(self, match: re.Match):
         logger = match.group("logger")
         description = match.group("description")
 
-        if logger == "werkzeug" and (http_match := re.match(self.ODOO_LOG_WERKZEUG_REGEX, description)):
+        if logger == "werkzeug" and (http_match := re.match(OdoobinProcess.LOG_WERKZEUG_REGEX, description)):
             dash = string.stylize("-", "color.black")
             code = http_match.group("code")
 
@@ -308,7 +274,7 @@ def _print_progress_log_line(self, match: re.Match):
 
     def _parse_progress_log_line(self, line: str) -> re.Match | None:
         """Parse a line of odoo-bin output."""
-        return re.match(self.ODOO_LOG_REGEX, string.strip_ansi_colors(line).replace("\r", ""))
+        return re.match(OdoobinProcess.LOG_REGEX, string.strip_ansi_colors(line).replace("\r", ""))
 
     def _colorize_duration_by_threshold(self, time: str | float, thresholds: Mapping[float, str]) -> str:
         """Colorize the textual representation of a duration according to thresholds.
diff --git a/odev/common/config.py b/odev/common/config.py
index 996058c2..5f7384cd 100644
--- a/odev/common/config.py
+++ b/odev/common/config.py
@@ -219,7 +219,7 @@ def get_date(self, version: str) -> datetime:
         """Last time a specific version was pulled from GitHub."""
         value = self.get(f"date_{version}")
         if not value:
-            return self.date
+            return datetime.fromtimestamp(0)
         return datetime.strptime(value, DATETIME_FORMAT)
 
     def set_date(self, version: str, value: datetime):
diff --git a/odev/common/databases/local.py b/odev/common/databases/local.py
index 0e015335..d9a73264 100644
--- a/odev/common/databases/local.py
+++ b/odev/common/databases/local.py
@@ -431,7 +431,7 @@ def installed_modules(self) -> list[str]:
 
     def _get_process_instance(self) -> OdoobinProcess:
         """Get the Odoo process for the database."""
-        return OdoobinProcess(
+        return self.odev.odoobin_process_class(
             self,
             (self.venv and self.venv.path.name) or str(self.version),
             self.worktree or (str(self.version) if self.version else None),
diff --git a/odev/common/debug.py b/odev/common/debug.py
index f1c4d238..1ed21d36 100644
--- a/odev/common/debug.py
+++ b/odev/common/debug.py
@@ -30,7 +30,9 @@ def find_debuggers(root: str | Path) -> Generator[tuple[Path, int], None, None]:
         raise NotADirectoryError(f"{root} is not a directory")
 
     try:
-        grep = bash.execute(rf"""grep -RnE "((i?pu?db)\.set_trace\(|pu\.db)" {root.as_posix()} --include='*.py'""")
+        grep = bash.execute(
+            rf"""grep -RnE "^[[:space:]]*[^#]*((i?pu?db)\.set_trace\(|pu\.db|breakpoint\(\))" {root.as_posix()} --include='*.py'"""
+        )
         output = grep.stdout.decode() if grep is not None else ""
     except subprocess.CalledProcessError:
         output = ""
diff --git a/odev/common/logging.py b/odev/common/logging.py
index 9d271e0f..d04b30cf 100644
--- a/odev/common/logging.py
+++ b/odev/common/logging.py
@@ -32,7 +32,7 @@
 DEBUG_SQL = False
 
 __log_level = re.search(
-    r"\s(?:-v\s?|--log-level(?:\s|=){1})([a-zA-Z-_]+)",
+    r"\s(?:-v|--log-level)(?:\s+|=)([a-zA-Z_]+)",
     " ".join(sys.argv),
 )
 
diff --git a/odev/common/mixins/framework/framework.py b/odev/common/mixins/framework/framework.py
index 03277f92..69a7f917 100644
--- a/odev/common/mixins/framework/framework.py
+++ b/odev/common/mixins/framework/framework.py
@@ -20,9 +20,9 @@ class OdevFrameworkMixin(ABC):
     def __init__(self, *args, **kwargs):
         """Initialize the mixin."""
         super().__init__(*args, **kwargs)
-        from odev.common import framework  # noqa: PLC0415 - avoid circular import at top level
+        from odev import common as _common  # noqa: PLC0415 - avoid circular import at top level
 
-        self.__class__._framework = framework
+        self.__class__._framework = _common.framework
 
     @property
     def odev(self) -> "Odev":
diff --git a/odev/common/odev.py b/odev/common/odev.py
index 13b154e9..de9940e2 100644
--- a/odev/common/odev.py
+++ b/odev/common/odev.py
@@ -19,6 +19,7 @@
 from time import monotonic, sleep
 from types import ModuleType
 from typing import (
+    TYPE_CHECKING,
     Any,
     ClassVar,
     Generic,
@@ -47,6 +48,10 @@
 from odev.common.telemetry import Telemetry
 
 
+if TYPE_CHECKING:
+    from odev.common.odoobin import OdoobinProcess as OdoobinProcessType
+
+
 try:
     from datetime import UTC
 except ImportError:  # UTC is only available in Python 3.11+
@@ -224,6 +229,7 @@ def plugins(self) -> Generator[Plugin, None, None]:
         """Yields enabled plugins sorted topologically."""
         for plugin_name in self._plugins_dependency_tree():
             plugin_path = self.plugins_path / plugin_name.split("/")[-1].replace("-", "_")
+
             plugin_manifest = self._load_plugin_manifest(plugin_path)
             yield Plugin(plugin_name, plugin_path, plugin_manifest)
 
@@ -243,6 +249,17 @@ def release(self) -> str:
 
         return f"dev:{branch}"
 
+    @property
+    def odoobin_process_class(self) -> "type[OdoobinProcessType]":
+        """The class used to spawn Odoo processes. Can be overridden by plugins."""
+        from odev.common.odoobin import OdoobinProcess  # noqa: PLC0415
+
+        return getattr(self, "_odoobin_process_class", OdoobinProcess)
+
+    @odoobin_process_class.setter
+    def odoobin_process_class(self, value: "type[OdoobinProcessType]") -> None:
+        self._odoobin_process_class = value
+
     def start(self, start_time: float | None = None) -> None:
         """Start the framework, check for updates and load plugins and commands.
 
@@ -262,11 +279,12 @@ def start(self, start_time: float | None = None) -> None:
 
         self.plugins_path.mkdir(parents=True, exist_ok=True)
 
-        if self.__should_update_now():
+        if self._should_update_now():
             self.check_release()
             self.update()
 
         with progress.spinner("Loading commands"):
+            self.load_plugins()
             self.register_commands()
             self.register_plugin_commands()
 
@@ -555,6 +573,57 @@ def register_commands(self) -> None:
             command_class.prepare_command(self)
             self.commands.update(dict.fromkeys(command_names, command_class))
 
+    def load_plugins(self) -> None:
+        """Import all enabled plugins to allow them to patch the framework."""
+        import odev  # noqa: PLC0415
+
+        # Ensure odev.plugins exists as a module so legacy imports work
+        if "odev.plugins" not in sys.modules:
+            plugins_module = ModuleType("odev.plugins")
+            plugins_module.__path__ = [str(self.plugins_path)]
+            plugins_module.__package__ = "odev.plugins"
+            plugins_module.__file__ = None
+            plugins_module.__spec__ = ModuleSpec("odev.plugins", None, is_package=True)
+            sys.modules["odev.plugins"] = plugins_module
+            if hasattr(odev, "__path__"):
+                odev.plugins = plugins_module
+
+        # Add plugins_path to sys.path to allow direct imports of plugin modules
+        if str(self.plugins_path) not in sys.path:
+            sys.path.insert(0, str(self.plugins_path))
+
+        for plugin in self.plugins:
+            logger.debug(
+                f"Loading plugin {plugin.name!r} version {string.stylize(plugin.manifest['version'], 'repr.version')}"
+            )
+
+            try:
+                # Module names MUST use underscores even if directories use dashes
+                plugin_module_name = plugin.path.name.replace("-", "_")
+                module_name = f"odev.plugins.{plugin_module_name}"
+
+                # Try to import directly from sys.path first
+                try:
+                    module = importlib.import_module(plugin_module_name)
+                except ImportError:
+                    # Fallback to explicit file loading if direct import fails
+                    init_path = plugin.path / "__init__.py"
+                    if not init_path.exists():
+                        continue
+                    spec = spec_from_file_location(plugin_module_name, init_path)
+                    if not spec or not spec.loader:
+                        continue
+                    module = module_from_spec(spec)
+                    sys.modules[plugin_module_name] = module
+                    spec.loader.exec_module(module)
+
+                # Ensure it's available as odev.plugins.X
+                sys.modules[module_name] = module
+                setattr(sys.modules["odev.plugins"], plugin_module_name, module)
+
+            except Exception as error:  # noqa: BLE001
+                logger.error(f"Could not load plugin module {plugin.path.name}: {error}")
+
     def register_plugin_commands(self) -> None:
         """Register commands for the plugins directories, pulling changes in plugins if an error arises while loading
         the commands.
@@ -579,29 +648,7 @@ def register_plugin_commands(self) -> None:
 
     def _register_plugin_commands(self) -> None:
         """Register all commands from the plugins directories."""
-        # Ensure odev.plugins exists as a module so legacy imports work
-        odev_module = sys.modules.get("odev")
-        if odev_module:
-            if not hasattr(odev_module, "plugins"):
-                odev_module.plugins = ModuleType("odev.plugins")
-                odev_module.plugins.__path__ = []
-                odev_module.plugins.__package__ = "odev.plugins"
-                odev_module.plugins.__spec__ = ModuleSpec("odev.plugins", None, is_package=True)
-                sys.modules["odev.plugins"] = odev_module.plugins
-
-            if str(self.plugins_path) not in odev_module.plugins.__path__:
-                odev_module.plugins.__path__.append(str(self.plugins_path))
-
         for plugin in self.plugins:
-            logger.debug(
-                f"Loading plugin {plugin.name!r} version {string.stylize(plugin.manifest['version'], 'repr.version')}"
-            )
-
-            try:
-                importlib.import_module(f"odev.plugins.{plugin.path.name}")
-            except ImportError as error:
-                logger.debug(f"Could not import plugin module {plugin.path.name}: {error}")
-
             for command_class in self.import_commands(plugin.path.glob("commands/**")):
                 command_names = [command_class._name] + (list(command_class._aliases) or [])
                 base_command_class = self.commands.get(command_class._name)
@@ -1085,7 +1132,7 @@ def __requirements_changed(self, repository: Repo) -> bool:
 
         return bool(diff)
 
-    def __should_update_now(self) -> bool:
+    def _should_update_now(self) -> bool:
         """Check whether the last check date is older than today minus the check interval.
 
         :return: Whether the last check date is older than today minus the check interval
diff --git a/odev/common/odoobin.py b/odev/common/odoobin.py
index b0e68d6a..be098c7b 100644
--- a/odev/common/odoobin.py
+++ b/odev/common/odoobin.py
@@ -78,6 +78,43 @@ class OdoobinProcess(OdevFrameworkMixin):
 
     cache_ps_process: ClassVar[TTLCache] = TTLCache(ttl=1)
 
+    LOG_REGEX: ClassVar[re.Pattern] = re.compile(
+        r"""
+            (?:
+                ((?P<date>\d{4}-\d{2}-\d{2})\s+)?
+                (?P<time>\d{2}:\d{2}:\d{2},\d{3})\s+
+                ((?P<pid>\d+)\s+)?
+                (?P<level>[A-Z]+)\s+
+                (?P<database>[^\s]+)\s+
+                (?P<logger>
+                    ((?:odoo\.addons\.)(?P<module>[^\.]+))?[^:]+
+                ):\s+
+                (?P<description>.*)
+            )
+        """,
+        re.VERBOSE | re.IGNORECASE,
+    )
+    """Regular expression to match the output of odoo-bin."""
+
+    LOG_WERKZEUG_REGEX: ClassVar[re.Pattern] = re.compile(
+        r"""
+            (?:
+                (?P<ip>(?:\d{1,3}\.){3}\d{1,3}).+?\]\s\"
+                (?P<verb>\w+)\s
+                (?P<url>.+?(?=\s))\s
+                (?P<http>.+?(?=\"))\"\s
+                (?P<code>\d+)\s-
+                (?:
+                    \s+(?P<count_query>\d+)\s
+                    (?P<time_query>[\d\.]+)\s
+                    (?P<time_remaining>[\d\.]+)
+                )?
+            )
+        """,
+        re.VERBOSE | re.IGNORECASE,
+    )
+    """Regular expression to match the output of odoo-bin Werkzeug-specific logs."""
+
     def __init__(
         self,
         database: "LocalDatabase",
@@ -122,7 +159,7 @@ def __init__(
 
     def __repr__(self) -> str:
         return (
-            "OdoobinProcess("
+            f"{self.__class__.__name__}("
             f"database={self.database.name!r}, "
             f"version={self.version!r}, "
             f"venv={self.venv!r}, "
@@ -546,7 +583,7 @@ def run(  # noqa: PLR0913
         subcommand: str | None = None,
         subcommand_input: str | None = None,
         stream: bool = True,
-        progress: Callable[[str], None] | None = None,
+        stream_filter: Callable[[str], str | None] | None = None,
         prepare: bool = False,
     ) -> CompletedProcess | None:
         """Run Odoo on the current database.
@@ -555,7 +592,7 @@ def run(  # noqa: PLR0913
         :param subcommand: Subcommand to pass to odoo-bin.
         :param subcommand_input: Input to pipe to the subcommand.
         :param stream: Whether to stream the output of the process.
-        :param progress: Callback to call on each line outputted by the process. Ignored if `stream` is False.
+        :param stream_filter: Callback to filter/process each line outputted by the process. Ignored if `stream` is False.
         :param prepare: Whether to prepare the environment before running. A missing venv is always prepared.
         :return: The return result of the process after completion.
         :rtype: subprocess.CompletedProcess
@@ -567,33 +604,46 @@ def run(  # noqa: PLR0913
             with spinner(f"Preparing odoo-bin version {str(self.version)!r} for database {self.database.name!r}"):
                 self.prepare_odoobin()
 
-        if stream and progress is not None:
+        if stream and stream_filter is not None:
             with spinner("Looking for calls to interactive debuggers"):
                 debuggers = [f"{file.as_posix()}:{line}" for file, line in self.addons_debuggers()]
 
             if debuggers:
                 logger.warning(f"Interactive debuggers detected in addons:\n{string.join_bullet(debuggers)}")
                 logger.warning("Disabling logs prettifying to avoid interfering with the debugger")
-                progress = None
+                stream_filter = None
 
         with capture_signals():
             odoo_command = f"odoo-bin {subcommand}" if subcommand is not None else "odoo-bin"
             odoobin_args = self.prepare_odoobin_args(args, subcommand)
             formatted_command = self.format_command(args, subcommand, subcommand_input)
             info_message = f"Running {odoo_command!r} in version '{self.version!s}' on database {self.database.name!r}"
-            logger.info(f"{info_message} using command:")
-            self.console.print()
-            self.console.print(formatted_command, soft_wrap=True, highlight=False)
+            self._print_run_info(info_message, formatted_command)
 
             try:
                 with spinner(info_message) if not stream else nullcontext():  # type: ignore[attr-defined]
                     self.database.venv = self.venv
                     self.database.worktree = self.worktree
+
+                    internal_filter = self.get_stream_filter()
+                    if internal_filter:
+                        original_filter = stream_filter
+
+                        def combined_filter(line: str) -> str | None:
+                            filtered_line = internal_filter(line)
+                            if filtered_line is not None:
+                                if original_filter:
+                                    return original_filter(filtered_line)
+                                return filtered_line
+                            return None
+
+                        stream_filter = combined_filter
+
                     process = self.venv.run_script(
                         self.odoobin_path,
                         odoobin_args,
                         stream=stream,
-                        progress=progress,
+                        stream_filter=stream_filter,
                         script_input=subcommand_input,
                     )
             except CalledProcessError as error:
@@ -943,3 +993,20 @@ def standardize(self, remove_studio: bool = False, dry: bool = False) -> Complet
                 return None
             else:
                 return process
+
+    def _print_run_info(self, info_message: str, formatted_command: str) -> None:
+        """Print information about the odoo-bin command being run.
+
+        Override this method in a subclass to suppress or customize the output
+        (e.g., inside an AI sandbox where verbose output wastes tokens).
+        """
+        logger.info(f"{info_message} using command:")
+        self.console.print()
+        self.console.print(formatted_command, soft_wrap=True, highlight=False)
+
+    def get_stream_filter(self) -> "Callable[[str], str | None] | None":
+        """Return a callable to filter each output line of the Odoo process, or None for no filtering.
+
+        Override this method in a subclass to provide custom log filtering behavior.
+        """
+        return None
diff --git a/odev/common/python.py b/odev/common/python.py
index 41898cd9..769b189d 100644
--- a/odev/common/python.py
+++ b/odev/common/python.py
@@ -528,15 +528,15 @@ def run_script(
         script: Path | str,
         args: list[str] | None = None,
         stream: bool = False,
-        progress: Callable[[str], None] | None = None,
+        stream_filter: Callable[[str], str | None] | None = None,
         script_input: str | None = None,
     ) -> CompletedProcess:
         """Run a python script.
 
-        :param path: Path to the python script to run.
+        :param script: Path to the python script to run.
         :param args: A list of arguments to pass to the script.
         :param stream: Whether to stream the output of the script to stdout.
-        :param progress: A callback function to call when a line is printed to stdout. Unused if stream is False.
+        :param stream_filter: A callback function to filter/process lines. Return None to skip a line.
         :param script_input: A string to pass to the script as stdin.
         :return: The result of the script execution.
         :rtype: CompletedProcess
@@ -554,15 +554,16 @@ def run_script(
         if not stream:
             return bash.execute(command, input_data=script_input)
 
-        if progress is None:
+        if stream_filter is None:
             return bash.run(command, input_data=script_input)
 
         output = []
         returncode = 0
         try:
             for line in bash.stream(command, input_data=script_input):
-                output.append(line)
-                progress(line)
+                processed_line = stream_filter(line)
+                if processed_line is not None:
+                    output.append(processed_line)
         except CalledProcessError as error:
             returncode = error.returncode
 
diff --git a/tests/fixtures/case.py b/tests/fixtures/case.py
index 7334ff2e..e0f8ea91 100644
--- a/tests/fixtures/case.py
+++ b/tests/fixtures/case.py
@@ -71,6 +71,8 @@ def tearDownClass(cls):
         if cls.run_path.exists():
             shutil.rmtree(cls.run_path, ignore_errors=True)
 
+        odev.HOME_PATH = (Path.home() / ".local" / "share" / "odev").resolve()
+
     @classmethod
     def patch(cls, target: Any, attribute: str, return_value: Any = None, **kwargs):
         """Patch an object's attribute.
diff --git a/tests/fixtures/odoobin_run_mock.py b/tests/fixtures/odoobin_run_mock.py
index f0d06870..8b3409db 100644
--- a/tests/fixtures/odoobin_run_mock.py
+++ b/tests/fixtures/odoobin_run_mock.py
@@ -68,7 +68,7 @@ def _stdout_for_odoo_argv(argv: list[str]) -> bytes:
 
 
 def _recording_run_script(  # noqa: PLR0913
-    call_log: list, self_pyenv, script, args=None, stream=False, progress=None, script_input=None
+    call_log: list, self_pyenv, script, args=None, stream=False, stream_filter=None, script_input=None, **kwargs
 ):
     script_path = Path(script).resolve()
     argv = list(args or [])
@@ -82,9 +82,9 @@ def start_run_script_recorder(call_log: list):
     """Patch PythonEnv.run_script to record calls and return success without subprocess."""
 
     def fake_run_script(  # noqa: PLR0913
-        self, script, args=None, stream=False, progress=None, script_input=None
+        self, script, args=None, stream=False, stream_filter=None, script_input=None, **kwargs
     ):
-        return _recording_run_script(call_log, self, script, args, stream, progress, script_input)
+        return _recording_run_script(call_log, self, script, args, stream, stream_filter, script_input, **kwargs)
 
     p = patch.object(PythonEnv, "run_script", fake_run_script)
     p.start()
diff --git a/tests/tests/commands/test_database.py b/tests/tests/commands/test_database.py
index 7a4cf150..ade716e4 100644
--- a/tests/tests/commands/test_database.py
+++ b/tests/tests/commands/test_database.py
@@ -500,7 +500,7 @@ def test_17_neutralize(self):
         neutralize.assert_called_once_with()
         self.assertIn("has been neutralized", stdout)
 
-    def test_16_dump(self):
+    def test_18_dump(self):
         """Command `odev dump` should report where the dump was saved."""
         dump_file = self.run_path / f"{self.database_name}.zip"
         with self.patch(LocalDatabase, "dump", return_value=dump_file):
diff --git a/tests/tests/commands/test_git_and_scripts.py b/tests/tests/commands/test_git_and_scripts.py
index 25b3864a..04927364 100644
--- a/tests/tests/commands/test_git_and_scripts.py
+++ b/tests/tests/commands/test_git_and_scripts.py
@@ -8,6 +8,11 @@
 
 
 class TestGitCommands(OdevCommandTestCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls._patch_object(GitConnector, [("fetch", None), ("prune_worktrees", None), ("_check_repository", None)])
+
     def test_01_clone_requires_target(self):
         _, stderr = self.dispatch_command("clone")
         self.assertIn("You must specify a database or repository to clone", stderr)
diff --git a/tests/tests/common/test_odev.py b/tests/tests/common/test_odev.py
index 4c6ae4f6..668d63c6 100644
--- a/tests/tests/common/test_odev.py
+++ b/tests/tests/common/test_odev.py
@@ -40,7 +40,7 @@ def test_03_restart(self):
     def test_04_restart_on_update(self):
         """Odev should restart itself when updated."""
         with (
-            self.patch(self.odev, "_Odev__should_update_now", return_value=True),
+            self.patch(self.odev, "_should_update_now", return_value=True),
             self.patch(self.odev, "_update", return_value=True),
             self.patch(self.odev, "restart") as mock_restart,
         ):
diff --git a/tests/tests/common/test_python_env.py b/tests/tests/common/test_python_env.py
index 050c9387..0ca92fd1 100644
--- a/tests/tests/common/test_python_env.py
+++ b/tests/tests/common/test_python_env.py
@@ -26,14 +26,14 @@ def test_run_script_streaming_success(self):
             self.patch(PythonEnv, "python", Path("/tmp/fake_venv/bin/python")),  # noqa: S108
             self.patch(bash, "stream", return_value=iter(["line 1", "line 2"])),
         ):
-            progress_mock = MagicMock()
-            result = env.run_script("fake_script.py", stream=True, progress=progress_mock)
+            stream_filter_mock = MagicMock(side_effect=lambda x: x)
+            result = env.run_script("fake_script.py", stream=True, stream_filter=stream_filter_mock)
 
             self.assertIsInstance(result, CompletedProcess)
             self.assertEqual(result.returncode, 0)
-            self.assertEqual(progress_mock.call_count, 2)
-            progress_mock.assert_any_call("line 1")
-            progress_mock.assert_any_call("line 2")
+            self.assertEqual(stream_filter_mock.call_count, 2)
+            stream_filter_mock.assert_any_call("line 1")
+            stream_filter_mock.assert_any_call("line 2")
 
     def test_run_script_streaming_failure(self):
         """Test run_script with a streaming process that fails."""
@@ -49,9 +49,9 @@ def streaming_failure(command, **_kwargs):
             self.patch(PythonEnv, "python", Path("/tmp/fake_venv/bin/python")),  # noqa: S108
             self.patch(bash, "stream", side_effect=streaming_failure),
         ):
-            progress_mock = MagicMock()
-            result = env.run_script("fake_script.py", stream=True, progress=progress_mock)
+            stream_filter_mock = MagicMock(side_effect=lambda x: x)
+            result = env.run_script("fake_script.py", stream=True, stream_filter=stream_filter_mock)
 
             self.assertIsInstance(result, CompletedProcess)
             self.assertEqual(result.returncode, 1)
-            progress_mock.assert_called_once_with("line 1")
+            stream_filter_mock.assert_called_once_with("line 1")