From a43112e832137847533f882d689a41a7034a1796 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Andreatta?= <sea@odoo.com>
Date: Fri, 24 Apr 2026 18:57:35 +0200
Subject: [PATCH 01/13] [IMP] various: implement sandbox log filtering and fix
 repo date logic

Add a token-efficient log filtering mechanism for the AI sandbox to suppress noisy HTTP logs and strip redundant metadata. This improves AI context clarity and reduces token usage. Also, fix RepositoriesSection.get_date to return a default epoch for new versions to ensure the initial pull logic works correctly.

Assisted-by: gemini-3-flash <noreply@google.com>
---
 odev/common/commands/odoobin.py | 39 ++-------------------
 odev/common/config.py           |  2 +-
 odev/common/odoobin.py          | 60 +++++++++++++++++++++++++++++++++
 odev/common/python.py           |  6 ++++
 4 files changed, 69 insertions(+), 38 deletions(-)

diff --git a/odev/common/commands/odoobin.py b/odev/common/commands/odoobin.py
index 4b2256e4..33ed2898 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."""
 
@@ -264,7 +229,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 +273,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/odoobin.py b/odev/common/odoobin.py
index b0e68d6a..7ba2fc61 100644
--- a/odev/common/odoobin.py
+++ b/odev/common/odoobin.py
@@ -1,5 +1,6 @@
 """Module to manage Odoo processes."""
 
+import os
 import re
 import shlex
 from ast import literal_eval
@@ -78,6 +79,41 @@ 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",
@@ -589,12 +625,16 @@ def run(  # noqa: PLR0913
                 with spinner(info_message) if not stream else nullcontext():  # type: ignore[attr-defined]
                     self.database.venv = self.venv
                     self.database.worktree = self.worktree
+
+                    stream_filter = self._ai_sandbox_filter if os.environ.get("AI_SANDBOX") == "1" else None
+
                     process = self.venv.run_script(
                         self.odoobin_path,
                         odoobin_args,
                         stream=stream,
                         progress=progress,
                         script_input=subcommand_input,
+                        stream_filter=stream_filter,
                     )
             except CalledProcessError as error:
                 if not stream:
@@ -943,3 +983,23 @@ def standardize(self, remove_studio: bool = False, dry: bool = False) -> Complet
                 return None
             else:
                 return process
+
+    def _ai_sandbox_filter(self, line: str) -> str | None:
+        """Filter Odoo logs to reduce token consumption when running in an AI sandbox."""
+        line = string.strip_ansi_colors(line).replace("\r", "")
+        match = self.LOG_REGEX.match(line)
+
+        if match:
+            description = match.group("description")
+            logger_name = match.group("logger")
+
+            # Suppress noisy werkzeug logs for successful requests
+            if logger_name == "werkzeug":
+                w_match = self.LOG_WERKZEUG_REGEX.match(description)
+                if w_match and w_match.group("code") in ("200", "304"):
+                    return None
+
+            # Return a cleaned version without date, time, pid, and database name
+            return f"{match.group('level')} {logger_name}: {description}"
+
+        return line
diff --git a/odev/common/python.py b/odev/common/python.py
index 41898cd9..8e444116 100644
--- a/odev/common/python.py
+++ b/odev/common/python.py
@@ -530,6 +530,7 @@ def run_script(
         stream: bool = False,
         progress: Callable[[str], None] | None = None,
         script_input: str | None = None,
+        stream_filter: Callable[[str], str | None] | None = None,
     ) -> CompletedProcess:
         """Run a python script.
 
@@ -561,6 +562,11 @@ def run_script(
         returncode = 0
         try:
             for line in bash.stream(command, input_data=script_input):
+                if stream_filter:
+                    filtered_line = stream_filter(line)
+                    if filtered_line is None:
+                        continue
+                    line = filtered_line
                 output.append(line)
                 progress(line)
         except CalledProcessError as error:

From 92b4bdcb5eb5cf83c6a61959f66272b36015c66f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Andreatta?= <sea@odoo.com>
Date: Fri, 24 Apr 2026 20:38:47 +0200
Subject: [PATCH 02/13] [IMP] core: optimize odoo logs for AI sandbox and
 pretty-printing

- Robust ODOO_LOG_REGEX to handle aligned logs (multiple spaces).
- Suppress odoo-bin command and info messages in AI sandbox to save tokens.
- Remove redundant database name from pretty-printed logs.

Assisted-by: gemini-3-flash <noreply@google.com>
---
 odev/common/odoobin.py | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/odev/common/odoobin.py b/odev/common/odoobin.py
index 7ba2fc61..62d91f70 100644
--- a/odev/common/odoobin.py
+++ b/odev/common/odoobin.py
@@ -82,14 +82,14 @@ class OdoobinProcess(OdevFrameworkMixin):
     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<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
+                ):\s+
                 (?P<description>.*)
             )
         """,
@@ -617,9 +617,10 @@ def run(  # noqa: PLR0913
             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)
+            if os.environ.get("AI_SANDBOX") != "1":
+                logger.info(f"{info_message} using command:")
+                self.console.print()
+                self.console.print(formatted_command, soft_wrap=True, highlight=False)
 
             try:
                 with spinner(info_message) if not stream else nullcontext():  # type: ignore[attr-defined]

From 74a3bd706f174908c527512af4daf8274529d44e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Andreatta?= <sea@odoo.com>
Date: Fri, 24 Apr 2026 20:41:00 +0200
Subject: [PATCH 03/13] [FIX] core: fix argument rescue logic for
 comma-separated lists

Fixed a bug where comma-separated lists (captured by 'addons' argument) were not correctly rescued from unknown flags, causing Odoo to misinterpret flags following '-i' as module names.

Assisted-by: gemini-3-flash <noreply@google.com>
---
 odev/common/commands/base.py | 12 ++++++------
 odev/common/debug.py         |  4 +++-
 2 files changed, 9 insertions(+), 7 deletions(-)

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/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 = ""

From 012983dd16c9169220ba200d02556522ed651c63 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Andreatta?= <sea@odoo.com>
Date: Sat, 25 Apr 2026 14:40:35 +0200
Subject: [PATCH 04/13] [IMP] skip self-update in AI sandbox

Assisted-by: Gemini 3 Flash <noreply@google.com>
---
 odev/common/odev.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/odev/common/odev.py b/odev/common/odev.py
index 13b154e9..a76e1ae0 100644
--- a/odev/common/odev.py
+++ b/odev/common/odev.py
@@ -936,7 +936,7 @@ def dispatch(self, argv: list[str] | None = None) -> bool:
 
     def check_release(self) -> None:
         """Check if a new release is available."""
-        if not self.git.repository or self.git.repository.head.is_detached:
+        if not self.git.repository or self.git.repository.head.is_detached or os.environ.get("AI_SANDBOX") == "1":
             return
 
         if self.git.repository.active_branch.name != self.config.update.release:
@@ -1091,6 +1091,9 @@ def __should_update_now(self) -> bool:
         :return: Whether the last check date is older than today minus the check interval
         :rtype: bool
         """
+        if os.environ.get("AI_SANDBOX") == "1" or os.environ.get("ODEV_SKIP_GIT_UPDATE") == "1":
+            return False
+
         return (datetime.today() - self.config.update.date).days >= self.config.update.interval
 
     def __update_prompt(self, name: str) -> bool:

From e6ef87d970e2c6adfb5e4fb518d9f53e67a3da0f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Andreatta?= <sea@odoo.com>
Date: Mon, 27 Apr 2026 15:23:16 +0200
Subject: [PATCH 05/13] [FIX] various: fix flaky tests and improve sandbox
 filtering regex

- Fix duplicate test name test_16 in test_database.py
- Mock GitConnector in TestGitCommands to avoid real cloning and hangs
- Fix LOG_WERKZEUG_REGEX to handle standard Werkzeug logs
- Restore HOME_PATH in OdevTestCase.tearDownClass for better test isolation

Assisted-by: antigravity <noreply@google.com>
---
 odev/common/logging.py                       |  2 +-
 odev/common/odoobin.py                       | 10 ++++++----
 odev/common/python.py                        |  9 +++++----
 tests/fixtures/case.py                       |  2 ++
 tests/fixtures/odoobin_run_mock.py           | 12 ++++++------
 tests/tests/commands/test_database.py        |  4 ++--
 tests/tests/commands/test_git_and_scripts.py |  5 +++++
 7 files changed, 27 insertions(+), 17 deletions(-)

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/odoobin.py b/odev/common/odoobin.py
index 62d91f70..b9a10b43 100644
--- a/odev/common/odoobin.py
+++ b/odev/common/odoobin.py
@@ -104,10 +104,12 @@ class OdoobinProcess(OdevFrameworkMixin):
                 (?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\.]+)
+                (?P<code>\d+)\s-
+                (?:
+                    \s+(?P<count_query>\d+)\s
+                    (?P<time_query>[\d\.]+)\s
+                    (?P<time_remaining>[\d\.]+)
+                )?
             )
         """,
         re.VERBOSE | re.IGNORECASE,
diff --git a/odev/common/python.py b/odev/common/python.py
index 8e444116..8e6657d1 100644
--- a/odev/common/python.py
+++ b/odev/common/python.py
@@ -523,7 +523,7 @@ def __check_package_conditions(self, conditional: str | None) -> bool:
             },
         )
 
-    def run_script(
+    def run_script(  # noqa: PLR0913
         self,
         script: Path | str,
         args: list[str] | None = None,
@@ -562,13 +562,14 @@ def run_script(
         returncode = 0
         try:
             for line in bash.stream(command, input_data=script_input):
+                processed_line = line
                 if stream_filter:
                     filtered_line = stream_filter(line)
                     if filtered_line is None:
                         continue
-                    line = filtered_line
-                output.append(line)
-                progress(line)
+                    processed_line = filtered_line
+                output.append(processed_line)
+                progress(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..4cf4c210 100644
--- a/tests/fixtures/odoobin_run_mock.py
+++ b/tests/fixtures/odoobin_run_mock.py
@@ -68,11 +68,11 @@ 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, progress=None, script_input=None, **kwargs
 ):
     script_path = Path(script).resolve()
     argv = list(args or [])
-    call_log.append((self_pyenv.python.resolve(), script_path, argv, stream, script_input))
+    call_log.append((self_pyenv.python.resolve(), script_path, argv, stream, script_input, kwargs.get("stream_filter")))
     cmd = f"{self_pyenv.python} {script_path} {' '.join(argv)}"
     out = _stdout_for_odoo_argv(argv)
     return CompletedProcess(cmd, 0, out, b"")
@@ -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, progress=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, progress, script_input, **kwargs)
 
     p = patch.object(PythonEnv, "run_script", fake_run_script)
     p.start()
@@ -115,7 +115,7 @@ def assert_last_odoobin_invocation(  # noqa: PLR0913
 ):
     odoos = list(iter_odoobin_calls(call_log))
     test_case.assertTrue(odoos, "expected at least one odoo-bin run_script call")
-    _interp, _script, argv, _stream, _inp = odoos[-1]
+    _interp, _script, argv, _stream, _inp, _filter = odoos[-1]
     test_case.assertEqual(_script.resolve(), FAKE_ODOOBIN_PATH.resolve())
     interp = _interp.resolve()
     sys_py = Path(sys.executable).resolve()
@@ -142,7 +142,7 @@ def assert_any_odoobin_invocation(
     predicate,
 ):
     """Assert at least one odoo call matches predicate(argv)."""
-    for _i, _s, argv, _st, _in in iter_odoobin_calls(call_log):
+    for _i, _s, argv, _st, _in, _f in iter_odoobin_calls(call_log):
         if predicate(argv):
             return
     test_case.fail("no odoo-bin invocation matched predicate")
diff --git a/tests/tests/commands/test_database.py b/tests/tests/commands/test_database.py
index 7a4cf150..603b0b87 100644
--- a/tests/tests/commands/test_database.py
+++ b/tests/tests/commands/test_database.py
@@ -420,7 +420,7 @@ def test_12_run_with_addons_path(self):
             database_name=self.database_name,
             argv_contains=["--stop-after-init"],
         )
-        _interp, _script, argv, _st, _inp = list(iter_odoobin_calls(self._odoobin_run_script_calls))[-1]
+        _interp, _script, argv, _st, _inp, _filter = list(iter_odoobin_calls(self._odoobin_run_script_calls))[-1]
         joined = " ".join(argv)
         self.assertIn(addons_path_end, joined)
         self.assertGreaterEqual(joined.count(addons_path_end), 2)
@@ -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)

From e68f56907058dd41104483f12a6097bf7aa0facf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Andreatta?= <sea@odoo.com>
Date: Mon, 27 Apr 2026 16:22:38 +0200
Subject: [PATCH 06/13] refactor: make OdoobinProcess substitutable via
 odev.odoobin_process_class

- Add odoobin_process_class property to Odev with getter/setter
- Add should_skip_update() hook method to Odev (replaces direct AI_SANDBOX checks)
- Replace OdoobinProcess.run AI_SANDBOX checks with odev.should_skip_update()
- Add OdoobinProcess.get_stream_filter() as an overridable hook (returns None)
- Remove _ai_sandbox_filter from core OdoobinProcess (moved to plugin)
- Update all OdoobinProcess instantiation sites to use odev.odoobin_process_class

Assisted-by: claude-sonnet-4-5 <noreply@google.com>
---
 odev/commands/database/create.py |  3 +--
 odev/commands/database/deploy.py |  2 +-
 odev/commands/database/test.py   |  2 +-
 odev/common/commands/odoobin.py  |  2 +-
 odev/common/databases/local.py   |  2 +-
 odev/common/odev.py              | 26 ++++++++++++++++++++++++--
 odev/common/odoobin.py           | 28 +++++++---------------------
 7 files changed, 36 insertions(+), 29 deletions(-)

diff --git a/odev/commands/database/create.py b/odev/commands/database/create.py
index 684aa9fd..bc2f1fdb 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,7 +175,7 @@ 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)
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/test.py b/odev/commands/database/test.py
index b5270b36..dfe1324f 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 = (
diff --git a/odev/common/commands/odoobin.py b/odev/common/commands/odoobin.py
index 33ed2898..84666cf8 100644
--- a/odev/common/commands/odoobin.py
+++ b/odev/common/commands/odoobin.py
@@ -214,7 +214,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,
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/odev.py b/odev/common/odev.py
index a76e1ae0..2634389a 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+
@@ -243,6 +248,23 @@ 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 should_skip_update(self) -> bool:
+        """Return whether odev and its plugins should skip checking for updates.
+        Can be overridden or extended by plugins.
+        """
+        return os.environ.get("AI_SANDBOX") == "1"
+
     def start(self, start_time: float | None = None) -> None:
         """Start the framework, check for updates and load plugins and commands.
 
@@ -936,7 +958,7 @@ def dispatch(self, argv: list[str] | None = None) -> bool:
 
     def check_release(self) -> None:
         """Check if a new release is available."""
-        if not self.git.repository or self.git.repository.head.is_detached or os.environ.get("AI_SANDBOX") == "1":
+        if not self.git.repository or self.git.repository.head.is_detached or self.should_skip_update():
             return
 
         if self.git.repository.active_branch.name != self.config.update.release:
@@ -1091,7 +1113,7 @@ def __should_update_now(self) -> bool:
         :return: Whether the last check date is older than today minus the check interval
         :rtype: bool
         """
-        if os.environ.get("AI_SANDBOX") == "1" or os.environ.get("ODEV_SKIP_GIT_UPDATE") == "1":
+        if self.should_skip_update() or os.environ.get("ODEV_SKIP_GIT_UPDATE") == "1":
             return False
 
         return (datetime.today() - self.config.update.date).days >= self.config.update.interval
diff --git a/odev/common/odoobin.py b/odev/common/odoobin.py
index b9a10b43..46023d79 100644
--- a/odev/common/odoobin.py
+++ b/odev/common/odoobin.py
@@ -1,6 +1,5 @@
 """Module to manage Odoo processes."""
 
-import os
 import re
 import shlex
 from ast import literal_eval
@@ -619,7 +618,7 @@ def run(  # noqa: PLR0913
             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}"
-            if os.environ.get("AI_SANDBOX") != "1":
+            if not self.odev.should_skip_update():
                 logger.info(f"{info_message} using command:")
                 self.console.print()
                 self.console.print(formatted_command, soft_wrap=True, highlight=False)
@@ -629,7 +628,7 @@ def run(  # noqa: PLR0913
                     self.database.venv = self.venv
                     self.database.worktree = self.worktree
 
-                    stream_filter = self._ai_sandbox_filter if os.environ.get("AI_SANDBOX") == "1" else None
+                    stream_filter = self.get_stream_filter()
 
                     process = self.venv.run_script(
                         self.odoobin_path,
@@ -987,22 +986,9 @@ def standardize(self, remove_studio: bool = False, dry: bool = False) -> Complet
             else:
                 return process
 
-    def _ai_sandbox_filter(self, line: str) -> str | None:
-        """Filter Odoo logs to reduce token consumption when running in an AI sandbox."""
-        line = string.strip_ansi_colors(line).replace("\r", "")
-        match = self.LOG_REGEX.match(line)
+    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.
 
-        if match:
-            description = match.group("description")
-            logger_name = match.group("logger")
-
-            # Suppress noisy werkzeug logs for successful requests
-            if logger_name == "werkzeug":
-                w_match = self.LOG_WERKZEUG_REGEX.match(description)
-                if w_match and w_match.group("code") in ("200", "304"):
-                    return None
-
-            # Return a cleaned version without date, time, pid, and database name
-            return f"{match.group('level')} {logger_name}: {description}"
-
-        return line
+        Override this method in a subclass to provide custom log filtering behavior.
+        """
+        return None

From 1fa7ae41a1adcdf4c70efd025bbfb9eec002585d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Andreatta?= <sea@odoo.com>
Date: Mon, 27 Apr 2026 16:24:22 +0200
Subject: [PATCH 07/13] refactor: use _print_run_info() override instead of
 should_skip_update() in OdoobinProcess
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Remove the odev.should_skip_update() call from OdoobinProcess.run — core stays
completely unaware of sandbox concepts. Instead, add an overridable
_print_run_info() that always prints by default; AI_OdoobinProcess overrides it
to be a no-op to save tokens inside the sandbox.

Assisted-by: claude-sonnet-4-5 <noreply@google.com>
---
 odev/common/odoobin.py | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/odev/common/odoobin.py b/odev/common/odoobin.py
index 46023d79..666f504f 100644
--- a/odev/common/odoobin.py
+++ b/odev/common/odoobin.py
@@ -618,10 +618,7 @@ def run(  # noqa: PLR0913
             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}"
-            if not self.odev.should_skip_update():
-                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]
@@ -986,6 +983,16 @@ def standardize(self, remove_studio: bool = False, dry: bool = False) -> Complet
             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.
 

From 5b90c76085bd066e7b80c4c74014e30f9ed283a3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Andreatta?= <sea@odoo.com>
Date: Mon, 27 Apr 2026 17:46:45 +0200
Subject: [PATCH 08/13] refactor: remove should_skip_update and all AI_SANDBOX
 references from core

Core odev now relies solely on ODEV_SKIP_GIT_UPDATE for update suppression,
leaving AI-specific behavior entirely to the plugin.

Assisted-by: claude-sonnet-4-5 <noreply@google.com>
---
 odev/common/odev.py | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/odev/common/odev.py b/odev/common/odev.py
index 2634389a..1227ce55 100644
--- a/odev/common/odev.py
+++ b/odev/common/odev.py
@@ -259,12 +259,6 @@ def odoobin_process_class(self) -> "type[OdoobinProcessType]":
     def odoobin_process_class(self, value: "type[OdoobinProcessType]") -> None:
         self._odoobin_process_class = value
 
-    def should_skip_update(self) -> bool:
-        """Return whether odev and its plugins should skip checking for updates.
-        Can be overridden or extended by plugins.
-        """
-        return os.environ.get("AI_SANDBOX") == "1"
-
     def start(self, start_time: float | None = None) -> None:
         """Start the framework, check for updates and load plugins and commands.
 
@@ -958,7 +952,11 @@ def dispatch(self, argv: list[str] | None = None) -> bool:
 
     def check_release(self) -> None:
         """Check if a new release is available."""
-        if not self.git.repository or self.git.repository.head.is_detached or self.should_skip_update():
+        if (
+            not self.git.repository
+            or self.git.repository.head.is_detached
+            or os.environ.get("ODEV_SKIP_GIT_UPDATE") == "1"
+        ):
             return
 
         if self.git.repository.active_branch.name != self.config.update.release:
@@ -1113,7 +1111,7 @@ def __should_update_now(self) -> bool:
         :return: Whether the last check date is older than today minus the check interval
         :rtype: bool
         """
-        if self.should_skip_update() or os.environ.get("ODEV_SKIP_GIT_UPDATE") == "1":
+        if os.environ.get("ODEV_SKIP_GIT_UPDATE") == "1":
             return False
 
         return (datetime.today() - self.config.update.date).days >= self.config.update.interval

From d61d1558a564e63e715787e726204768a8688ad6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Andreatta?= <sea@odoo.com>
Date: Mon, 27 Apr 2026 19:30:24 +0200
Subject: [PATCH 09/13] refactor: clean up update hooks and implement native
 stream filtering

- Revert check_release and rename __should_update_now to _should_update_now
- Implement native stream filtering in run_script (supporting None to skip)
- Move AI-specific sandbox logic entirely to the plugin via overrides
- Rename progress to stream_filter and update all call sites

Assisted-by: claude-sonnet-4-5 <noreply@google.com>
---
 odev/_version.py                       |  2 +-
 odev/commands/database/create.py       |  2 +-
 odev/commands/database/run.py          |  2 +-
 odev/commands/database/test.py         |  2 +-
 odev/commands/database/upgrade_code.py |  2 +-
 odev/common/commands/odoobin.py        |  5 +++--
 odev/common/odev.py                    | 13 +++----------
 odev/common/odoobin.py                 | 25 ++++++++++++++++++-------
 odev/common/python.py                  | 22 ++++++++--------------
 tests/fixtures/odoobin_run_mock.py     | 12 ++++++------
 tests/tests/commands/test_database.py  |  2 +-
 tests/tests/common/test_odev.py        |  2 +-
 tests/tests/common/test_python_env.py  | 16 ++++++++--------
 13 files changed, 53 insertions(+), 54 deletions(-)

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 bc2f1fdb..57432319 100644
--- a/odev/commands/database/create.py
+++ b/odev/commands/database/create.py
@@ -182,7 +182,7 @@ def initialize_database(self) -> None:
         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/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 dfe1324f..afb3057f 100644
--- a/odev/commands/database/test.py
+++ b/odev/commands/database/test.py
@@ -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/odoobin.py b/odev/common/commands/odoobin.py
index 84666cf8..a6088f56 100644
--- a/odev/common/commands/odoobin.py
+++ b/odev/common/commands/odoobin.py
@@ -145,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."""
diff --git a/odev/common/odev.py b/odev/common/odev.py
index 1227ce55..cf463f71 100644
--- a/odev/common/odev.py
+++ b/odev/common/odev.py
@@ -278,7 +278,7 @@ 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()
 
@@ -952,11 +952,7 @@ def dispatch(self, argv: list[str] | None = None) -> bool:
 
     def check_release(self) -> None:
         """Check if a new release is available."""
-        if (
-            not self.git.repository
-            or self.git.repository.head.is_detached
-            or os.environ.get("ODEV_SKIP_GIT_UPDATE") == "1"
-        ):
+        if not self.git.repository or self.git.repository.head.is_detached:
             return
 
         if self.git.repository.active_branch.name != self.config.update.release:
@@ -1105,15 +1101,12 @@ 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
         :rtype: bool
         """
-        if os.environ.get("ODEV_SKIP_GIT_UPDATE") == "1":
-            return False
-
         return (datetime.today() - self.config.update.date).days >= self.config.update.interval
 
     def __update_prompt(self, name: str) -> bool:
diff --git a/odev/common/odoobin.py b/odev/common/odoobin.py
index 666f504f..c49c6aad 100644
--- a/odev/common/odoobin.py
+++ b/odev/common/odoobin.py
@@ -583,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.
@@ -592,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
@@ -604,14 +604,14 @@ 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"
@@ -625,15 +625,26 @@ def run(  # noqa: PLR0913
                     self.database.venv = self.venv
                     self.database.worktree = self.worktree
 
-                    stream_filter = self.get_stream_filter()
+                    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,
-                        script_input=subcommand_input,
                         stream_filter=stream_filter,
+                        script_input=subcommand_input,
                     )
             except CalledProcessError as error:
                 if not stream:
diff --git a/odev/common/python.py b/odev/common/python.py
index 8e6657d1..769b189d 100644
--- a/odev/common/python.py
+++ b/odev/common/python.py
@@ -523,21 +523,20 @@ def __check_package_conditions(self, conditional: str | None) -> bool:
             },
         )
 
-    def run_script(  # noqa: PLR0913
+    def run_script(
         self,
         script: Path | str,
         args: list[str] | None = None,
         stream: bool = False,
-        progress: Callable[[str], None] | None = None,
-        script_input: str | 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
@@ -555,21 +554,16 @@ def run_script(  # noqa: PLR0913
         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):
-                processed_line = line
-                if stream_filter:
-                    filtered_line = stream_filter(line)
-                    if filtered_line is None:
-                        continue
-                    processed_line = filtered_line
-                output.append(processed_line)
-                progress(processed_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/odoobin_run_mock.py b/tests/fixtures/odoobin_run_mock.py
index 4cf4c210..8b3409db 100644
--- a/tests/fixtures/odoobin_run_mock.py
+++ b/tests/fixtures/odoobin_run_mock.py
@@ -68,11 +68,11 @@ 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, **kwargs
+    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 [])
-    call_log.append((self_pyenv.python.resolve(), script_path, argv, stream, script_input, kwargs.get("stream_filter")))
+    call_log.append((self_pyenv.python.resolve(), script_path, argv, stream, script_input))
     cmd = f"{self_pyenv.python} {script_path} {' '.join(argv)}"
     out = _stdout_for_odoo_argv(argv)
     return CompletedProcess(cmd, 0, out, b"")
@@ -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, **kwargs
+        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, **kwargs)
+        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()
@@ -115,7 +115,7 @@ def assert_last_odoobin_invocation(  # noqa: PLR0913
 ):
     odoos = list(iter_odoobin_calls(call_log))
     test_case.assertTrue(odoos, "expected at least one odoo-bin run_script call")
-    _interp, _script, argv, _stream, _inp, _filter = odoos[-1]
+    _interp, _script, argv, _stream, _inp = odoos[-1]
     test_case.assertEqual(_script.resolve(), FAKE_ODOOBIN_PATH.resolve())
     interp = _interp.resolve()
     sys_py = Path(sys.executable).resolve()
@@ -142,7 +142,7 @@ def assert_any_odoobin_invocation(
     predicate,
 ):
     """Assert at least one odoo call matches predicate(argv)."""
-    for _i, _s, argv, _st, _in, _f in iter_odoobin_calls(call_log):
+    for _i, _s, argv, _st, _in in iter_odoobin_calls(call_log):
         if predicate(argv):
             return
     test_case.fail("no odoo-bin invocation matched predicate")
diff --git a/tests/tests/commands/test_database.py b/tests/tests/commands/test_database.py
index 603b0b87..ade716e4 100644
--- a/tests/tests/commands/test_database.py
+++ b/tests/tests/commands/test_database.py
@@ -420,7 +420,7 @@ def test_12_run_with_addons_path(self):
             database_name=self.database_name,
             argv_contains=["--stop-after-init"],
         )
-        _interp, _script, argv, _st, _inp, _filter = list(iter_odoobin_calls(self._odoobin_run_script_calls))[-1]
+        _interp, _script, argv, _st, _inp = list(iter_odoobin_calls(self._odoobin_run_script_calls))[-1]
         joined = " ".join(argv)
         self.assertIn(addons_path_end, joined)
         self.assertGreaterEqual(joined.count(addons_path_end), 2)
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")

From f8e3a355211de784cf8e367d6ad7ed4761d3d28b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Andreatta?= <sea@odoo.com>
Date: Tue, 28 Apr 2026 11:27:33 +0200
Subject: [PATCH 10/13] [IMP] common: allow overriding OdoobinProcess class and
 improve plugin loading

- Add `_odoobin_process_class` to `OdevFrameworkMixin` for flexible Odoo process specialization.
- Refactor plugin loading to use direct imports and ensure `odev.plugins` namespace is correctly populated.
- Minor improvements to `OdoobinProcess` representation and output formatting.

Assisted-by: gemini-3-flash <noreply@google.com>
---
 odev/common/mixins/framework/framework.py |  4 +-
 odev/common/odev.py                       | 82 ++++++++++++++++-------
 odev/common/odoobin.py                    |  3 +-
 3 files changed, 63 insertions(+), 26 deletions(-)

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 cf463f71..fedc0a2c 100644
--- a/odev/common/odev.py
+++ b/odev/common/odev.py
@@ -228,7 +228,13 @@ def dumps_path(self) -> Path:
     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("-", "_")
+            # Try underscored version first (default)
+            plugin_dir_name = plugin_name.split("/")[-1].replace("-", "_")
+            plugin_path = self.plugins_path / plugin_dir_name
+            if not plugin_path.exists():
+                # Fallback to original name (e.g. with dashes)
+                plugin_path = self.plugins_path / plugin_name.split("/")[-1]
+
             plugin_manifest = self._load_plugin_manifest(plugin_path)
             yield Plugin(plugin_name, plugin_path, plugin_manifest)
 
@@ -283,6 +289,7 @@ def start(self, start_time: float | None = None) -> None:
             self.update()
 
         with progress.spinner("Loading commands"):
+            self.load_plugins()
             self.register_commands()
             self.register_plugin_commands()
 
@@ -571,6 +578,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.
@@ -595,29 +653,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)
diff --git a/odev/common/odoobin.py b/odev/common/odoobin.py
index c49c6aad..4d553d51 100644
--- a/odev/common/odoobin.py
+++ b/odev/common/odoobin.py
@@ -159,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}, "
@@ -1003,6 +1003,7 @@ def _print_run_info(self, info_message: str, formatted_command: str) -> None:
         logger.info(f"{info_message} using command:")
         self.console.print()
         self.console.print(formatted_command, soft_wrap=True, highlight=False)
+        self.console.print()
 
     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.

From 6dd64f8ef415e0a4a5fad5d6aa1008df10fa4997 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Andreatta?= <sea@odoo.com>
Date: Tue, 28 Apr 2026 11:40:24 +0200
Subject: [PATCH 11/13] [FIX] common: revert plugin path fallback and extra
 newline in run info

- Revert plugin path fallback logic in `plugins` property.
- Remove extra newline in `_print_run_info` to keep output compact.

Assisted-by: gemini-3-flash <noreply@google.com>
---
 odev/common/odev.py    | 7 +------
 odev/common/odoobin.py | 1 -
 2 files changed, 1 insertion(+), 7 deletions(-)

diff --git a/odev/common/odev.py b/odev/common/odev.py
index fedc0a2c..de9940e2 100644
--- a/odev/common/odev.py
+++ b/odev/common/odev.py
@@ -228,12 +228,7 @@ def dumps_path(self) -> Path:
     def plugins(self) -> Generator[Plugin, None, None]:
         """Yields enabled plugins sorted topologically."""
         for plugin_name in self._plugins_dependency_tree():
-            # Try underscored version first (default)
-            plugin_dir_name = plugin_name.split("/")[-1].replace("-", "_")
-            plugin_path = self.plugins_path / plugin_dir_name
-            if not plugin_path.exists():
-                # Fallback to original name (e.g. with dashes)
-                plugin_path = self.plugins_path / plugin_name.split("/")[-1]
+            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)
diff --git a/odev/common/odoobin.py b/odev/common/odoobin.py
index 4d553d51..be098c7b 100644
--- a/odev/common/odoobin.py
+++ b/odev/common/odoobin.py
@@ -1003,7 +1003,6 @@ def _print_run_info(self, info_message: str, formatted_command: str) -> None:
         logger.info(f"{info_message} using command:")
         self.console.print()
         self.console.print(formatted_command, soft_wrap=True, highlight=False)
-        self.console.print()
 
     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.

From b3bee397a5088ad160f1c224b1048fe75bc724d9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Andreatta?= <sea@odoo.com>
Date: Tue, 28 Apr 2026 11:43:51 +0200
Subject: [PATCH 12/13] [IMP] common: improve command run info display and
 restore spacing

- Use richer console output for the Odev run message.
- Restore the extra newline after the command for better readability.

Assisted-by: gemini-3-flash <noreply@google.com>
---
 odev/common/odoobin.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/odev/common/odoobin.py b/odev/common/odoobin.py
index be098c7b..46183776 100644
--- a/odev/common/odoobin.py
+++ b/odev/common/odoobin.py
@@ -1000,9 +1000,10 @@ def _print_run_info(self, info_message: str, formatted_command: str) -> None:
         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(f"[bold color.purple]odev[/bold color.purple] [color.cyan]{info_message}[/color.cyan]")
         self.console.print()
         self.console.print(formatted_command, soft_wrap=True, highlight=False)
+        self.console.print()
 
     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.

From fe563ba154dc44e8c9fe2d0605c4da426b6f0686 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Andreatta?= <sea@odoo.com>
Date: Tue, 28 Apr 2026 14:23:34 +0200
Subject: [PATCH 13/13] [FIX] common: revert command run info display to fix
 tests\n\n- Restore logger.info for info_message to ensure tests can capture
 it\n- Remove custom rich styling and extra spacing\n\nAssisted-by:
 gemini-3-flash <noreply@google.com>

---
 odev/common/odoobin.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/odev/common/odoobin.py b/odev/common/odoobin.py
index 46183776..be098c7b 100644
--- a/odev/common/odoobin.py
+++ b/odev/common/odoobin.py
@@ -1000,10 +1000,9 @@ def _print_run_info(self, info_message: str, formatted_command: str) -> None:
         Override this method in a subclass to suppress or customize the output
         (e.g., inside an AI sandbox where verbose output wastes tokens).
         """
-        self.console.print(f"[bold color.purple]odev[/bold color.purple] [color.cyan]{info_message}[/color.cyan]")
+        logger.info(f"{info_message} using command:")
         self.console.print()
         self.console.print(formatted_command, soft_wrap=True, highlight=False)
-        self.console.print()
 
     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.