chore: import upstream snapshot with attribution

tests/unit_tests/core/__init__.py

@@ -0,0 +1 @@
+"""Core module unit tests."""

tests/unit_tests/core/test_app_config_validation.py

@@ -0,0 +1,192 @@
+"""Unit tests for core app config validation methods.
+
+Tests cover:
+- _get_positive_int_config() validation
+- _get_positive_float_config() validation
+"""
+
+from __future__ import annotations
+
+from unittest.mock import Mock
+from importlib import import_module
+
+
+def get_app_module():
+    """Lazy import to avoid circular import issues."""
+    return import_module('langbot.pkg.core.app')
+
+
+class TestGetPositiveIntConfig:
+    """Tests for _get_positive_int_config method."""
+
+    def test_returns_value_when_valid_positive_int(self):
+        """Test returns parsed int for valid positive value."""
+        app_module = get_app_module()
+
+        mock_logger = Mock()
+
+        app = app_module.Application()
+        app.logger = mock_logger
+
+        result = app._get_positive_int_config(10, default=30, name='test.config')
+
+        assert result == 10
+        mock_logger.warning.assert_not_called()
+
+    def test_returns_value_when_valid_string_int(self):
+        """Test returns parsed int for string value."""
+        app_module = get_app_module()
+
+        mock_logger = Mock()
+
+        app = app_module.Application()
+        app.logger = mock_logger
+
+        result = app._get_positive_int_config('50', default=30, name='test.config')
+
+        assert result == 50
+        mock_logger.warning.assert_not_called()
+
+    def test_returns_default_for_zero(self):
+        """Test returns default when value is zero."""
+        app_module = get_app_module()
+
+        mock_logger = Mock()
+
+        app = app_module.Application()
+        app.logger = mock_logger
+
+        result = app._get_positive_int_config(0, default=30, name='test.config')
+
+        assert result == 30
+        mock_logger.warning.assert_called_once()
+
+    def test_returns_default_for_negative(self):
+        """Test returns default when value is negative."""
+        app_module = get_app_module()
+
+        mock_logger = Mock()
+
+        app = app_module.Application()
+        app.logger = mock_logger
+
+        result = app._get_positive_int_config(-5, default=30, name='test.config')
+
+        assert result == 30
+        mock_logger.warning.assert_called_once()
+
+    def test_returns_default_for_invalid_string(self):
+        """Test returns default when value is invalid string."""
+        app_module = get_app_module()
+
+        mock_logger = Mock()
+
+        app = app_module.Application()
+        app.logger = mock_logger
+
+        result = app._get_positive_int_config('invalid', default=30, name='test.config')
+
+        assert result == 30
+        mock_logger.warning.assert_called_once()
+
+    def test_returns_default_for_none(self):
+        """Test returns default when value is None."""
+        app_module = get_app_module()
+
+        mock_logger = Mock()
+
+        app = app_module.Application()
+        app.logger = mock_logger
+
+        result = app._get_positive_int_config(None, default=30, name='test.config')
+
+        assert result == 30
+        mock_logger.warning.assert_called_once()
+
+
+class TestGetPositiveFloatConfig:
+    """Tests for _get_positive_float_config method."""
+
+    def test_returns_value_when_valid_positive_float(self):
+        """Test returns parsed float for valid positive value."""
+        app_module = get_app_module()
+
+        mock_logger = Mock()
+
+        app = app_module.Application()
+        app.logger = mock_logger
+
+        result = app._get_positive_float_config(1.5, default=2.0, name='test.config')
+
+        assert result == 1.5
+        mock_logger.warning.assert_not_called()
+
+    def test_returns_value_when_valid_int(self):
+        """Test returns float for valid int value."""
+        app_module = get_app_module()
+
+        mock_logger = Mock()
+
+        app = app_module.Application()
+        app.logger = mock_logger
+
+        result = app._get_positive_float_config(2, default=1.0, name='test.config')
+
+        assert result == 2.0
+        mock_logger.warning.assert_not_called()
+
+    def test_returns_value_when_valid_string_float(self):
+        """Test returns parsed float for string value."""
+        app_module = get_app_module()
+
+        mock_logger = Mock()
+
+        app = app_module.Application()
+        app.logger = mock_logger
+
+        result = app._get_positive_float_config('0.5', default=1.0, name='test.config')
+
+        assert result == 0.5
+        mock_logger.warning.assert_not_called()
+
+    def test_returns_default_for_zero(self):
+        """Test returns default when value is zero."""
+        app_module = get_app_module()
+
+        mock_logger = Mock()
+
+        app = app_module.Application()
+        app.logger = mock_logger
+
+        result = app._get_positive_float_config(0.0, default=1.0, name='test.config')
+
+        assert result == 1.0
+        mock_logger.warning.assert_called_once()
+
+    def test_returns_default_for_negative(self):
+        """Test returns default when value is negative."""
+        app_module = get_app_module()
+
+        mock_logger = Mock()
+
+        app = app_module.Application()
+        app.logger = mock_logger
+
+        result = app._get_positive_float_config(-1.0, default=2.0, name='test.config')
+
+        assert result == 2.0
+        mock_logger.warning.assert_called_once()
+
+    def test_returns_default_for_invalid_string(self):
+        """Test returns default when value is invalid string."""
+        app_module = get_app_module()
+
+        mock_logger = Mock()
+
+        app = app_module.Application()
+        app.logger = mock_logger
+
+        result = app._get_positive_float_config('not-a-number', default=1.5, name='test.config')
+
+        assert result == 1.5
+        mock_logger.warning.assert_called_once()

tests/unit_tests/core/test_boot.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import signal
+from types import SimpleNamespace
+
+import pytest
+
+from langbot.pkg.core import boot
+
+
+@pytest.mark.asyncio
+async def test_main_signal_handler_handles_sigint_before_app_created(monkeypatch):
+    captured_handler = {}
+
+    def fake_signal(sig, handler):
+        captured_handler[sig] = handler
+
+    async def fake_make_app(loop):
+        captured_handler[signal.SIGINT](signal.SIGINT, None)
+
+    def fake_exit(code):
+        raise SystemExit(code)
+
+    monkeypatch.setattr(signal, 'signal', fake_signal)
+    monkeypatch.setattr(boot, 'make_app', fake_make_app)
+    monkeypatch.setattr(boot.os, '_exit', fake_exit)
+
+    with pytest.raises(SystemExit) as exc_info:
+        await boot.main(SimpleNamespace())
+
+    assert exc_info.value.code == 0
+
+
+@pytest.mark.asyncio
+async def test_main_signal_handler_disposes_created_app(monkeypatch):
+    captured_handler = {}
+    app_inst = SimpleNamespace(disposed=False)
+
+    def fake_signal(sig, handler):
+        captured_handler[sig] = handler
+
+    def dispose():
+        app_inst.disposed = True
+
+    async def run():
+        captured_handler[signal.SIGINT](signal.SIGINT, None)
+
+    async def fake_make_app(loop):
+        app_inst.dispose = dispose
+        app_inst.run = run
+        return app_inst
+
+    def fake_exit(code):
+        raise SystemExit(code)
+
+    monkeypatch.setattr(signal, 'signal', fake_signal)
+    monkeypatch.setattr(boot, 'make_app', fake_make_app)
+    monkeypatch.setattr(boot.os, '_exit', fake_exit)
+
+    with pytest.raises(SystemExit) as exc_info:
+        await boot.main(SimpleNamespace())
+
+    assert exc_info.value.code == 0
+    assert app_inst.disposed is True

tests/unit_tests/core/test_bootutils_deps.py

@@ -0,0 +1,139 @@
+"""Tests for core bootutils dependency checking."""
+
+from __future__ import annotations
+
+import importlib.util
+from unittest.mock import MagicMock, patch
+
+from tests.utils.import_isolation import isolated_sys_modules
+
+
+class TestCheckDeps:
+    """Tests for check_deps function."""
+
+    def _make_deps_import_mocks(self):
+        """Create mocks for deps import."""
+        return {
+            'langbot.pkg.utils.pkgmgr': MagicMock(),
+        }
+
+    def test_check_deps_all_present(self):
+        """check_deps returns empty list when all deps present."""
+        mocks = self._make_deps_import_mocks()
+
+        with isolated_sys_modules(mocks):
+            # Mock find_spec to always return a spec (module found)
+            with patch.object(importlib.util, 'find_spec', return_value=MagicMock()):
+                from langbot.pkg.core.bootutils.deps import check_deps
+
+                import asyncio
+
+                result = asyncio.get_event_loop().run_until_complete(check_deps())
+
+                assert result == []
+
+    def test_check_deps_missing_deps(self):
+        """check_deps returns list of missing deps."""
+        mocks = self._make_deps_import_mocks()
+
+        with isolated_sys_modules(mocks):
+            # Mock find_spec to return None for some deps
+            def mock_find_spec(name):
+                if name in ['requests', 'openai']:
+                    return None  # Missing
+                return MagicMock()  # Present
+
+            with patch.object(importlib.util, 'find_spec', side_effect=mock_find_spec):
+                from langbot.pkg.core.bootutils.deps import check_deps
+
+                import asyncio
+
+                result = asyncio.get_event_loop().run_until_complete(check_deps())
+
+                assert 'requests' in result
+                assert 'openai' in result
+
+    def test_check_deps_all_missing(self):
+        """check_deps returns all deps when none present."""
+        mocks = self._make_deps_import_mocks()
+
+        with isolated_sys_modules(mocks):
+            # Mock find_spec to always return None
+            with patch.object(importlib.util, 'find_spec', return_value=None):
+                from langbot.pkg.core.bootutils.deps import check_deps, required_deps
+
+                import asyncio
+
+                result = asyncio.get_event_loop().run_until_complete(check_deps())
+
+                # Should include all required_deps keys
+                assert len(result) == len(required_deps)
+
+    def test_required_deps_dict_exists(self):
+        """required_deps dictionary is defined."""
+        mocks = self._make_deps_import_mocks()
+
+        with isolated_sys_modules(mocks):
+            from langbot.pkg.core.bootutils.deps import required_deps
+
+            assert isinstance(required_deps, dict)
+            assert len(required_deps) > 0
+            # Check some expected deps
+            assert 'requests' in required_deps
+            assert 'yaml' in required_deps
+
+    def test_required_deps_maps_import_name_to_package_name(self):
+        """required_deps maps import name to package name."""
+        mocks = self._make_deps_import_mocks()
+
+        with isolated_sys_modules(mocks):
+            from langbot.pkg.core.bootutils.deps import required_deps
+
+            # Some import names differ from package names
+            assert required_deps['PIL'] == 'pillow'
+            assert required_deps['yaml'] == 'pyyaml'
+            assert required_deps['jwt'] == 'pyjwt'
+
+
+class TestPrecheckPluginDeps:
+    """Tests for precheck_plugin_deps function."""
+
+    def _make_deps_import_mocks(self):
+        return {
+            'langbot.pkg.utils.pkgmgr': MagicMock(),
+        }
+
+    def test_precheck_plugin_deps_no_plugins_dir(self):
+        """precheck_plugin_deps skips when plugins dir doesn't exist."""
+        from langbot.pkg.core.bootutils.deps import precheck_plugin_deps
+
+        with patch('os.path.exists', return_value=False):
+            with patch('langbot.pkg.core.bootutils.deps.pkgmgr.install_requirements') as mock_install:
+                import asyncio
+
+                asyncio.get_event_loop().run_until_complete(precheck_plugin_deps())
+
+                mock_install.assert_not_called()
+
+    def test_precheck_plugin_deps_with_plugins_dir(self):
+        """precheck_plugin_deps checks plugins subdirectories."""
+        from langbot.pkg.core.bootutils.deps import precheck_plugin_deps
+
+        def mock_listdir(path):
+            if path == 'plugins':
+                return ['plugin1', 'plugin2']
+            if path == 'plugins/plugin1':
+                return ['requirements.txt', 'main.py']
+            if path == 'plugins/plugin2':
+                return ['main.py']
+            return []
+
+        with patch('os.path.exists', return_value=True):
+            with patch('os.path.isdir', return_value=True):
+                with patch('os.listdir', side_effect=mock_listdir):
+                    with patch('langbot.pkg.core.bootutils.deps.pkgmgr.install_requirements') as mock_install:
+                        import asyncio
+
+                        asyncio.get_event_loop().run_until_complete(precheck_plugin_deps())
+
+        mock_install.assert_called_once_with('plugins/plugin1/requirements.txt', extra_params=[])

tests/unit_tests/core/test_bootutils_log.py

@@ -0,0 +1,120 @@
+"""Tests for the daily-grouped rotating log file handler.
+
+Regression coverage for the bug where a long-running process names its log
+file after the *start* day and keeps appending to it across midnight, so no
+file ever appears for the current day. See
+``langbot.pkg.core.bootutils.log.DailyGroupedRotatingFileHandler``.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import re
+
+import langbot.pkg.core.bootutils.log as logmod
+from langbot.pkg.core.bootutils.log import DailyGroupedRotatingFileHandler
+
+# Mirror of the cleanup pattern in api/http/service/maintenance.py.
+MAINTENANCE_LOG_FILE_PATTERN = re.compile(r'^langbot-(\d{4}-\d{2}-\d{2})\.log(?:\.\d+)?$')
+
+
+def _listing(directory):
+    return sorted(os.listdir(directory))
+
+
+def _make_logger(handler, name):
+    logger = logging.getLogger(name)
+    logger.setLevel(logging.INFO)
+    logger.handlers.clear()
+    logger.addHandler(handler)
+    logger.propagate = False
+    return logger
+
+
+class TestDailyGroupedRotatingFileHandler:
+    def _patch_date(self, monkeypatch, box):
+        """Make the handler read its current date from ``box['date']``."""
+
+        def fake_strftime(fmt, t=None):
+            if fmt == '%Y-%m-%d':
+                return box['date']
+            return '00:00:00'
+
+        monkeypatch.setattr(logmod.time, 'strftime', fake_strftime)
+
+    def test_initial_file_named_for_current_day(self, tmp_path, monkeypatch):
+        box = {'date': '2026-06-08'}
+        self._patch_date(monkeypatch, box)
+
+        handler = DailyGroupedRotatingFileHandler(str(tmp_path), max_bytes=10_000, backup_count=3)
+        logger = _make_logger(handler, 'lb_logtest_initial')
+        logger.info('hello')
+        handler.close()
+
+        assert _listing(tmp_path) == ['langbot-2026-06-08.log']
+
+    def test_same_day_size_rotation_creates_numbered_backups(self, tmp_path, monkeypatch):
+        box = {'date': '2026-06-08'}
+        self._patch_date(monkeypatch, box)
+
+        handler = DailyGroupedRotatingFileHandler(str(tmp_path), max_bytes=200, backup_count=3)
+        logger = _make_logger(handler, 'lb_logtest_size')
+        for i in range(40):
+            logger.info('padding line to exceed maxBytes %d', i)
+        handler.close()
+
+        files = _listing(tmp_path)
+        assert 'langbot-2026-06-08.log' in files
+        assert any(f.startswith('langbot-2026-06-08.log.') for f in files)
+
+    def test_rolls_to_new_file_when_day_changes(self, tmp_path, monkeypatch):
+        box = {'date': '2026-06-08'}
+        self._patch_date(monkeypatch, box)
+
+        handler = DailyGroupedRotatingFileHandler(str(tmp_path), max_bytes=10_000, backup_count=3)
+        logger = _make_logger(handler, 'lb_logtest_midnight')
+        logger.info('day1 line')
+
+        # Simulate crossing midnight within the same running process.
+        box['date'] = '2026-06-09'
+        logger.info('day2 line after midnight')
+        handler.close()
+
+        files = _listing(tmp_path)
+        assert 'langbot-2026-06-08.log' in files
+        assert 'langbot-2026-06-09.log' in files
+
+        day2 = (tmp_path / 'langbot-2026-06-09.log').read_text(encoding='utf-8')
+        assert 'day2 line after midnight' in day2
+        assert 'day1 line' not in day2
+
+    def test_rollover_repeats_across_multiple_days(self, tmp_path, monkeypatch):
+        box = {'date': '2026-06-08'}
+        self._patch_date(monkeypatch, box)
+
+        handler = DailyGroupedRotatingFileHandler(str(tmp_path), max_bytes=10_000, backup_count=3)
+        logger = _make_logger(handler, 'lb_logtest_multiday')
+        for day in ('2026-06-08', '2026-06-09', '2026-06-10'):
+            box['date'] = day
+            logger.info('line for %s', day)
+        handler.close()
+
+        files = _listing(tmp_path)
+        for day in ('2026-06-08', '2026-06-09', '2026-06-10'):
+            assert f'langbot-{day}.log' in files
+
+    def test_all_filenames_match_maintenance_cleanup_pattern(self, tmp_path, monkeypatch):
+        box = {'date': '2026-06-08'}
+        self._patch_date(monkeypatch, box)
+
+        handler = DailyGroupedRotatingFileHandler(str(tmp_path), max_bytes=200, backup_count=3)
+        logger = _make_logger(handler, 'lb_logtest_pattern')
+        for i in range(40):
+            logger.info('padding line %d', i)
+        box['date'] = '2026-06-09'
+        logger.info('next day line')
+        handler.close()
+
+        for name in _listing(tmp_path):
+            assert MAINTENANCE_LOG_FILE_PATTERN.match(name), name

tests/unit_tests/core/test_load_config.py

@@ -0,0 +1,284 @@
+"""Unit tests for core stages load_config _apply_env_overrides_to_config.
+
+Tests cover:
+- Environment variable parsing and path conversion
+- Type conversion (bool, int, float, string)
+- List handling (comma-separated)
+- Dict type skipping
+- Missing key creation
+"""
+
+from __future__ import annotations
+
+import os
+from unittest.mock import patch
+from importlib import import_module
+
+
+def get_load_config_module():
+    """Lazy import to avoid circular import issues."""
+    return import_module('langbot.pkg.core.stages.load_config')
+
+
+class TestApplyEnvOverridesToConfig:
+    """Tests for _apply_env_overrides_to_config function."""
+
+    def test_override_string_value(self):
+        """Test overriding an existing string config value."""
+        load_config = get_load_config_module()
+
+        cfg = {'system': {'name': 'default'}}
+        env = {'SYSTEM__NAME': 'custom_name'}
+
+        with patch.dict(os.environ, env, clear=True):
+            result = load_config._apply_env_overrides_to_config(cfg)
+
+        assert result['system']['name'] == 'custom_name'
+
+    def test_override_int_value(self):
+        """Test overriding an int value with proper conversion."""
+        load_config = get_load_config_module()
+
+        cfg = {'concurrency': {'pipeline': 5}}
+        env = {'CONCURRENCY__PIPELINE': '10'}
+
+        with patch.dict(os.environ, env, clear=True):
+            result = load_config._apply_env_overrides_to_config(cfg)
+
+        assert result['concurrency']['pipeline'] == 10
+        assert isinstance(result['concurrency']['pipeline'], int)
+
+    def test_override_int_value_invalid_conversion(self):
+        """Test that invalid int conversion keeps string value."""
+        load_config = get_load_config_module()
+
+        cfg = {'concurrency': {'pipeline': 5}}
+        env = {'CONCURRENCY__PIPELINE': 'not_a_number'}
+
+        with patch.dict(os.environ, env, clear=True):
+            result = load_config._apply_env_overrides_to_config(cfg)
+
+        # Falls back to string when conversion fails
+        assert result['concurrency']['pipeline'] == 'not_a_number'
+
+    def test_override_bool_value_true(self):
+        """Test overriding bool value with 'true' string."""
+        load_config = get_load_config_module()
+
+        cfg = {'system': {'enable': False}}
+        env = {'SYSTEM__ENABLE': 'true'}
+
+        with patch.dict(os.environ, env, clear=True):
+            result = load_config._apply_env_overrides_to_config(cfg)
+
+        assert result['system']['enable'] is True
+
+    def test_override_bool_value_false(self):
+        """Test overriding bool value with 'false' string."""
+        load_config = get_load_config_module()
+
+        cfg = {'system': {'enable': True}}
+        env = {'SYSTEM__ENABLE': 'false'}
+
+        with patch.dict(os.environ, env, clear=True):
+            result = load_config._apply_env_overrides_to_config(cfg)
+
+        assert result['system']['enable'] is False
+
+    def test_override_bool_value_various_true_forms(self):
+        """Test that '1', 'yes', 'on' are treated as true."""
+        load_config = get_load_config_module()
+
+        cfg = {'system': {'flag': False}}
+
+        for true_val in ['1', 'yes', 'on', 'TRUE']:
+            env = {'SYSTEM__FLAG': true_val}
+            with patch.dict(os.environ, env, clear=True):
+                result = load_config._apply_env_overrides_to_config(cfg.copy())
+                assert result['system']['flag'] is True
+
+    def test_override_float_value(self):
+        """Test overriding float value with proper conversion."""
+        load_config = get_load_config_module()
+
+        cfg = {'system': {'timeout': 1.5}}
+        env = {'SYSTEM__TIMEOUT': '2.5'}
+
+        with patch.dict(os.environ, env, clear=True):
+            result = load_config._apply_env_overrides_to_config(cfg)
+
+        assert result['system']['timeout'] == 2.5
+        assert isinstance(result['system']['timeout'], float)
+
+    def test_override_list_value(self):
+        """Test that comma-separated string converts to list."""
+        load_config = get_load_config_module()
+
+        cfg = {'system': {'disabled_adapters': ['adapter1']}}
+        env = {'SYSTEM__DISABLED_ADAPTERS': 'aiocqhttp,dingtalk,telegram'}
+
+        with patch.dict(os.environ, env, clear=True):
+            result = load_config._apply_env_overrides_to_config(cfg)
+
+        assert result['system']['disabled_adapters'] == ['aiocqhttp', 'dingtalk', 'telegram']
+
+    def test_override_list_value_empty_items(self):
+        """Test that empty items in comma-separated list are filtered."""
+        load_config = get_load_config_module()
+
+        cfg = {'system': {'disabled_adapters': []}}
+        env = {'SYSTEM__DISABLED_ADAPTERS': 'a,,b,,,c'}
+
+        with patch.dict(os.environ, env, clear=True):
+            result = load_config._apply_env_overrides_to_config(cfg)
+
+        # Empty items should be filtered out
+        assert result['system']['disabled_adapters'] == ['a', 'b', 'c']
+
+    def test_skip_dict_type_override(self):
+        """Test that dict type values are skipped."""
+        load_config = get_load_config_module()
+
+        cfg = {'plugin': {'settings': {'nested': 'value'}}}
+        env = {'PLUGIN__SETTINGS': 'should_not_apply'}
+
+        with patch.dict(os.environ, env, clear=True):
+            result = load_config._apply_env_overrides_to_config(cfg)
+
+        # Dict type should not be overridden
+        assert result['plugin']['settings'] == {'nested': 'value'}
+
+    def test_create_new_key_when_missing(self):
+        """Test that missing keys are created as strings."""
+        load_config = get_load_config_module()
+
+        cfg = {'system': {}}
+        env = {'SYSTEM__NEW_KEY': 'new_value'}
+
+        with patch.dict(os.environ, env, clear=True):
+            result = load_config._apply_env_overrides_to_config(cfg)
+
+        assert result['system']['new_key'] == 'new_value'
+
+    def test_create_nested_path(self):
+        """Test that intermediate dict is created for nested path."""
+        load_config = get_load_config_module()
+
+        cfg = {}
+        env = {'NEW__SECTION__KEY': 'value'}
+
+        with patch.dict(os.environ, env, clear=True):
+            result = load_config._apply_env_overrides_to_config(cfg)
+
+        assert result['new']['section']['key'] == 'value'
+
+    def test_skip_non_uppercase_env_vars(self):
+        """Test that non-uppercase env vars are skipped."""
+        load_config = get_load_config_module()
+
+        cfg = {'system': {'name': 'default'}}
+        env = {'system__name': 'should_not_apply'}
+
+        with patch.dict(os.environ, env, clear=True):
+            result = load_config._apply_env_overrides_to_config(cfg)
+
+        assert result['system']['name'] == 'default'
+
+    def test_skip_env_vars_without_double_underscore(self):
+        """Test that env vars without __ are skipped."""
+        load_config = get_load_config_module()
+
+        cfg = {'system': {'name': 'default'}}
+        env = {'SYSTEMNAME': 'should_not_apply'}
+
+        with patch.dict(os.environ, env, clear=True):
+            result = load_config._apply_env_overrides_to_config(cfg)
+
+        assert result['system']['name'] == 'default'
+
+    def test_nested_config_path(self):
+        """Test overriding deeply nested config."""
+        load_config = get_load_config_module()
+
+        cfg = {'level1': {'level2': {'level3': 'original'}}}
+        env = {'LEVEL1__LEVEL2__LEVEL3': 'overridden'}
+
+        with patch.dict(os.environ, env, clear=True):
+            result = load_config._apply_env_overrides_to_config(cfg)
+
+        assert result['level1']['level2']['level3'] == 'overridden'
+
+    def test_non_dict_current_breaks(self):
+        """Test that path navigation stops when current is not dict."""
+        load_config = get_load_config_module()
+
+        cfg = {'system': 'not_a_dict'}
+        env = {'SYSTEM__NAME': 'should_not_apply'}
+
+        with patch.dict(os.environ, env, clear=True):
+            result = load_config._apply_env_overrides_to_config(cfg)
+
+        # Should remain unchanged since 'system' is not a dict
+        assert result == {'system': 'not_a_dict'}
+
+    def test_empty_config(self):
+        """Test that empty config dict is handled."""
+        load_config = get_load_config_module()
+
+        cfg = {}
+        env = {'SOME__KEY': 'value'}
+
+        with patch.dict(os.environ, env, clear=True):
+            result = load_config._apply_env_overrides_to_config(cfg)
+
+        assert result['some']['key'] == 'value'
+
+    def test_no_matching_env_vars(self):
+        """Test that config is unchanged when no matching env vars."""
+        load_config = get_load_config_module()
+
+        cfg = {'system': {'name': 'default'}}
+        env = {'OTHER_VAR': 'value'}
+
+        with patch.dict(os.environ, env, clear=True):
+            result = load_config._apply_env_overrides_to_config(cfg)
+
+        assert result == cfg
+
+    def test_multiple_env_vars_override(self):
+        """Test multiple env vars applied in order."""
+        load_config = get_load_config_module()
+
+        cfg = {'system': {'name': 'default', 'enable': True}, 'concurrency': {'pipeline': 5}}
+        env = {'SYSTEM__NAME': 'custom', 'SYSTEM__ENABLE': 'false', 'CONCURRENCY__PIPELINE': '10'}
+
+        with patch.dict(os.environ, env, clear=True):
+            result = load_config._apply_env_overrides_to_config(cfg)
+
+        assert result['system']['name'] == 'custom'
+        assert result['system']['enable'] is False
+        assert result['concurrency']['pipeline'] == 10
+
+    def test_webhook_prefix_override(self):
+        """Test overriding webhook_prefix via environment variable."""
+        load_config = get_load_config_module()
+
+        cfg = {'api': {'port': 5300, 'webhook_prefix': 'http://127.0.0.1:5300', 'extra_webhook_prefix': ''}}
+        env = {'API__WEBHOOK_PREFIX': 'https://example.com:8080'}
+
+        with patch.dict(os.environ, env, clear=True):
+            result = load_config._apply_env_overrides_to_config(cfg)
+
+        assert result['api']['webhook_prefix'] == 'https://example.com:8080'
+
+    def test_extra_webhook_prefix_override(self):
+        """Test overriding extra_webhook_prefix via environment variable."""
+        load_config = get_load_config_module()
+
+        cfg = {'api': {'port': 5300, 'webhook_prefix': 'http://127.0.0.1:5300', 'extra_webhook_prefix': ''}}
+        env = {'API__EXTRA_WEBHOOK_PREFIX': 'https://extra.example.com'}
+
+        with patch.dict(os.environ, env, clear=True):
+            result = load_config._apply_env_overrides_to_config(cfg)
+
+        assert result['api']['extra_webhook_prefix'] == 'https://extra.example.com'

tests/unit_tests/core/test_stage.py

@@ -0,0 +1,178 @@
+"""Tests for core boot stage registration and abstract classes."""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+import pytest
+
+from tests.utils.import_isolation import isolated_sys_modules
+
+
+class TestStageClassDecorator:
+    """Tests for @stage_class decorator."""
+
+    def _make_stage_import_mocks(self):
+        """Create mocks for stage import."""
+        return {
+            'langbot.pkg.core.app': MagicMock(),
+        }
+
+    def test_stage_class_registers_stage(self):
+        """@stage_class registers stage in preregistered_stages."""
+        mocks = self._make_stage_import_mocks()
+
+        with isolated_sys_modules(mocks):
+            from langbot.pkg.core.stage import stage_class, preregistered_stages
+
+            # Clear for clean test
+            preregistered_stages.clear()
+
+            @stage_class('TestStage')
+            class TestStage:
+                pass
+
+            assert 'TestStage' in preregistered_stages
+            assert preregistered_stages['TestStage'] == TestStage
+
+    def test_stage_class_returns_original_class(self):
+        """@stage_class returns the original class unchanged."""
+        mocks = self._make_stage_import_mocks()
+
+        with isolated_sys_modules(mocks):
+            from langbot.pkg.core.stage import stage_class
+
+            @stage_class('TestStage')
+            class TestStage:
+                value = 42
+
+            # Class attributes should be preserved
+            assert TestStage.value == 42
+
+    def test_stage_class_multiple_stages(self):
+        """Multiple stages can be registered."""
+        mocks = self._make_stage_import_mocks()
+
+        with isolated_sys_modules(mocks):
+            from langbot.pkg.core.stage import stage_class, preregistered_stages
+
+            preregistered_stages.clear()
+
+            @stage_class('Stage1')
+            class Stage1:
+                pass
+
+            @stage_class('Stage2')
+            class Stage2:
+                pass
+
+            assert len(preregistered_stages) == 2
+            assert preregistered_stages['Stage1'] == Stage1
+            assert preregistered_stages['Stage2'] == Stage2
+
+
+class TestBootingStageAbstract:
+    """Tests for BootingStage abstract class."""
+
+    def _make_stage_import_mocks(self):
+        return {'langbot.pkg.core.app': MagicMock()}
+
+    def test_booting_stage_is_abstract(self):
+        """BootingStage is abstract and cannot be instantiated directly."""
+        mocks = self._make_stage_import_mocks()
+
+        with isolated_sys_modules(mocks):
+            from langbot.pkg.core.stage import BootingStage
+
+            with pytest.raises(TypeError):
+                BootingStage()
+
+    def test_booting_stage_requires_run_method(self):
+        """Subclass must implement run method."""
+        mocks = self._make_stage_import_mocks()
+
+        with isolated_sys_modules(mocks):
+            from langbot.pkg.core.stage import BootingStage
+
+            class IncompleteStage(BootingStage):
+                pass
+
+            with pytest.raises(TypeError):
+                IncompleteStage()
+
+    def test_booting_stage_subclass_works(self):
+        """Complete subclass can be instantiated."""
+        mocks = self._make_stage_import_mocks()
+
+        with isolated_sys_modules(mocks):
+            from langbot.pkg.core.stage import BootingStage
+
+            class CompleteStage(BootingStage):
+                name = 'CompleteStage'
+
+                async def run(self, ap):
+                    pass
+
+            stage = CompleteStage()
+            assert stage.name == 'CompleteStage'
+
+    def test_booting_stage_name_attribute(self):
+        """BootingStage has name attribute (None by default in abstract)."""
+        mocks = self._make_stage_import_mocks()
+
+        with isolated_sys_modules(mocks):
+            from langbot.pkg.core.stage import BootingStage
+
+            # Abstract class has name attribute defined as None
+            assert hasattr(BootingStage, 'name')
+
+    @pytest.mark.asyncio
+    async def test_booting_stage_run_signature(self):
+        """run method receives Application parameter."""
+        mocks = self._make_stage_import_mocks()
+
+        with isolated_sys_modules(mocks):
+            from langbot.pkg.core.stage import BootingStage
+
+            class TestStage(BootingStage):
+                name = 'TestStage'
+
+                async def run(self, ap):
+                    self.ap_received = ap
+
+            stage = TestStage()
+            mock_ap = MagicMock()
+
+            await stage.run(mock_ap)
+            assert stage.ap_received == mock_ap
+
+
+class TestPreregisteredStages:
+    """Tests for preregistered_stages global registry."""
+
+    def _make_stage_import_mocks(self):
+        return {'langbot.pkg.core.app': MagicMock()}
+
+    def test_preregistered_stages_is_dict(self):
+        """preregistered_stages is a dictionary."""
+        mocks = self._make_stage_import_mocks()
+
+        with isolated_sys_modules(mocks):
+            from langbot.pkg.core.stage import preregistered_stages
+
+            assert isinstance(preregistered_stages, dict)
+
+    def test_preregistered_stages_key_is_string(self):
+        """Registry keys are stage names (strings)."""
+        mocks = self._make_stage_import_mocks()
+
+        with isolated_sys_modules(mocks):
+            from langbot.pkg.core.stage import stage_class, preregistered_stages
+
+            preregistered_stages.clear()
+
+            @stage_class('MyStage')
+            class MyStage:
+                pass
+
+            for key in preregistered_stages:
+                assert isinstance(key, str)

tests/unit_tests/core/test_taskmgr.py

@@ -0,0 +1,506 @@
+"""Unit tests for core TaskContext, TaskWrapper, and AsyncTaskManager.
+
+Tests cover:
+- TaskContext initialization, state tracking, serialization
+- TaskWrapper ID generation, to_dict serialization
+- AsyncTaskManager task creation, stats, pruning
+
+Note: Uses import_isolation to break circular import chains.
+"""
+
+from __future__ import annotations
+
+import pytest
+import asyncio
+import sys
+from unittest.mock import Mock, MagicMock
+from contextlib import contextmanager
+from typing import Generator
+
+
+class MockLifecycleControlScopeEnum:
+    """Mock enum value for LifecycleControlScope with .value attribute."""
+
+    def __init__(self, value: str):
+        self.value = value
+
+    def __repr__(self):
+        return f'LifecycleControlScope.{self.value.upper()}'
+
+
+class MockLifecycleControlScope:
+    """Mock enum for LifecycleControlScope."""
+
+    APPLICATION = MockLifecycleControlScopeEnum('application')
+    PLATFORM = MockLifecycleControlScopeEnum('platform')
+    PIPELINE = MockLifecycleControlScopeEnum('pipeline')
+    PLUGIN = MockLifecycleControlScopeEnum('plugin')
+
+
+@contextmanager
+def isolated_taskmgr_import() -> Generator[None, None, None]:
+    """Context manager to isolate circular imports for taskmgr testing."""
+    # Mock modules that cause circular imports
+    mock_entities = MagicMock()
+    mock_entities.LifecycleControlScope = MockLifecycleControlScope
+
+    mock_app = MagicMock()
+
+    mock_importutil = MagicMock()
+    mock_importutil.import_modules_in_pkg = lambda pkg: None
+    mock_importutil.import_modules_in_pkgs = lambda pkgs: None
+
+    mock_http_controller = MagicMock()
+
+    mock_rag_mgr = MagicMock()
+
+    mocks = {
+        'langbot.pkg.core.entities': mock_entities,
+        'langbot.pkg.core.app': mock_app,
+        'langbot.pkg.api.http.controller.main': mock_http_controller,
+        'langbot.pkg.rag.knowledge.kbmgr': mock_rag_mgr,
+        'langbot.pkg.utils.importutil': mock_importutil,
+    }
+
+    # Save original state
+    saved = {}
+    for name in mocks:
+        if name in sys.modules:
+            saved[name] = sys.modules[name]
+
+    # Clear taskmgr to force re-import
+    taskmgr_name = 'langbot.pkg.core.taskmgr'
+    if taskmgr_name in sys.modules:
+        saved[taskmgr_name] = sys.modules[taskmgr_name]
+
+    try:
+        # Apply mocks
+        for name, module in mocks.items():
+            sys.modules[name] = module
+
+        # Clear taskmgr
+        sys.modules.pop(taskmgr_name, None)
+
+        yield
+    finally:
+        # Restore
+        for name in mocks:
+            if name in saved:
+                sys.modules[name] = saved[name]
+            else:
+                sys.modules.pop(name, None)
+
+        if taskmgr_name in saved:
+            sys.modules[taskmgr_name] = saved[taskmgr_name]
+        else:
+            sys.modules.pop(taskmgr_name, None)
+
+
+def get_taskmgr_classes():
+    """Get TaskContext, TaskWrapper, AsyncTaskManager classes."""
+    with isolated_taskmgr_import():
+        from langbot.pkg.core.taskmgr import TaskContext, TaskWrapper, AsyncTaskManager
+
+        return TaskContext, TaskWrapper, AsyncTaskManager
+
+
+def create_mock_app():
+    """Create a mock Application for testing."""
+    mock_app = Mock()
+    mock_app.event_loop = asyncio.get_running_loop()
+    mock_app.instance_config = Mock()
+    mock_app.instance_config.data = {
+        'system': {
+            'task_retention': {
+                'completed_limit': 200,
+            }
+        }
+    }
+    return mock_app
+
+
+class TestTaskContext:
+    """Tests for TaskContext class."""
+
+    def test_init_default_values(self):
+        """Test that TaskContext initializes with default values."""
+        TaskContext, _, _ = get_taskmgr_classes()
+        ctx = TaskContext()
+
+        assert ctx.current_action == 'default'
+        assert ctx.log == ''
+        assert ctx.metadata == {}
+
+    def test_set_current_action(self):
+        """Test setting current action."""
+        TaskContext, _, _ = get_taskmgr_classes()
+        ctx = TaskContext()
+
+        ctx.set_current_action('installing_plugin')
+        assert ctx.current_action == 'installing_plugin'
+
+    def test_trace_without_action(self):
+        """Test trace method without action override."""
+        TaskContext, _, _ = get_taskmgr_classes()
+        ctx = TaskContext()
+
+        ctx.trace('Starting process')
+        assert 'Starting process' in ctx.log
+        assert ctx.current_action == 'default'
+
+    def test_trace_with_action_override(self):
+        """Test trace method with action override."""
+        TaskContext, _, _ = get_taskmgr_classes()
+        ctx = TaskContext()
+
+        ctx.trace('Downloading', action='download')
+        assert 'Downloading' in ctx.log
+        assert ctx.current_action == 'download'
+
+    def test_trace_accumulates_logs(self):
+        """Test that trace accumulates log entries."""
+        TaskContext, _, _ = get_taskmgr_classes()
+        ctx = TaskContext()
+
+        ctx.trace('Step 1')
+        ctx.trace('Step 2')
+        ctx.trace('Step 3')
+
+        assert 'Step 1' in ctx.log
+        assert 'Step 2' in ctx.log
+        assert 'Step 3' in ctx.log
+        # Each trace adds a newline
+        assert ctx.log.count('\n') == 3
+
+    def test_to_dict_serialization(self):
+        """Test to_dict serialization."""
+        TaskContext, _, _ = get_taskmgr_classes()
+        ctx = TaskContext()
+        ctx.set_current_action('test_action')
+        ctx.trace('Test message')
+        ctx.metadata['key'] = 'value'
+
+        result = ctx.to_dict()
+
+        assert result['current_action'] == 'test_action'
+        assert 'Test message' in result['log']
+        assert result['metadata'] == {'key': 'value'}
+
+    def test_static_new_factory(self):
+        """Test TaskContext.new() factory method."""
+        TaskContext, _, _ = get_taskmgr_classes()
+        ctx = TaskContext.new()
+
+        assert isinstance(ctx, TaskContext)
+        assert ctx.current_action == 'default'
+
+    def test_static_placeholder_singleton(self):
+        """Test TaskContext.placeholder() returns singleton."""
+        with isolated_taskmgr_import():
+            from langbot.pkg.core.taskmgr import TaskContext
+
+            # Reset global placeholder
+            import langbot.pkg.core.taskmgr as taskmgr_module
+
+            taskmgr_module.placeholder_context = None
+
+            ctx1 = TaskContext.placeholder()
+            ctx2 = TaskContext.placeholder()
+
+            assert ctx1 is ctx2
+
+    def test_metadata_is_mutable_dict(self):
+        """Test that metadata is a mutable dict."""
+        TaskContext, _, _ = get_taskmgr_classes()
+        ctx = TaskContext()
+
+        ctx.metadata['count'] = 5
+        ctx.metadata['items'] = ['a', 'b', 'c']
+
+        assert ctx.metadata['count'] == 5
+        assert len(ctx.metadata['items']) == 3
+
+
+class TestTaskWrapper:
+    """Tests for TaskWrapper class."""
+
+    @pytest.mark.asyncio
+    async def test_id_auto_increment(self):
+        """Test that task IDs auto-increment."""
+        TaskContext, TaskWrapper, _ = get_taskmgr_classes()
+
+        # Reset ID index
+        TaskWrapper._id_index = 0
+
+        mock_app = create_mock_app()
+
+        async def dummy_coro():
+            await asyncio.sleep(0.01)
+            return 'done'
+
+        wrapper1 = TaskWrapper(mock_app, dummy_coro())
+        wrapper2 = TaskWrapper(mock_app, dummy_coro())
+
+        assert wrapper1.id == 0
+        assert wrapper2.id == 1
+
+        # Clean up
+        wrapper1.cancel()
+        wrapper2.cancel()
+
+    @pytest.mark.asyncio
+    async def test_default_task_type_and_kind(self):
+        """Test default task_type and kind values."""
+        _, TaskWrapper, _ = get_taskmgr_classes()
+        mock_app = create_mock_app()
+
+        async def dummy_coro():
+            return 'done'
+
+        wrapper = TaskWrapper(mock_app, dummy_coro())
+
+        assert wrapper.task_type == 'system'
+        assert wrapper.kind == 'system_task'
+
+        wrapper.cancel()
+
+    @pytest.mark.asyncio
+    async def test_to_dict_serialization(self):
+        """Test TaskWrapper.to_dict serialization."""
+        _, TaskWrapper, _ = get_taskmgr_classes()
+        mock_app = create_mock_app()
+
+        async def immediate_coro():
+            return 'result'
+
+        wrapper = TaskWrapper(
+            mock_app,
+            immediate_coro(),
+            name='test_task',
+            label='Test Task',
+        )
+
+        # Wait for task to complete
+        await wrapper.task
+
+        result = wrapper.to_dict()
+
+        assert result['name'] == 'test_task'
+        assert result['label'] == 'Test Task'
+        assert result['task_type'] == 'system'
+        assert result['runtime']['done'] == True
+        assert result['runtime']['result'] == 'result'
+
+    @pytest.mark.asyncio
+    async def test_to_dict_with_exception(self):
+        """Test TaskWrapper.to_dict when task has exception."""
+        _, TaskWrapper, _ = get_taskmgr_classes()
+        mock_app = create_mock_app()
+
+        async def failing_coro():
+            raise ValueError('Test error')
+
+        wrapper = TaskWrapper(mock_app, failing_coro())
+
+        # Wait for task to complete
+        try:
+            await wrapper.task
+        except ValueError:
+            pass
+
+        result = wrapper.to_dict()
+
+        assert result['runtime']['done'] == True
+        assert result['runtime']['exception'] == 'Test error'
+        assert 'exception_traceback' in result['runtime']
+
+    @pytest.mark.asyncio
+    async def test_cancel_task(self):
+        """Test cancel method cancels the asyncio task."""
+        _, TaskWrapper, _ = get_taskmgr_classes()
+        mock_app = create_mock_app()
+
+        async def long_coro():
+            await asyncio.sleep(10)
+            return 'done'
+
+        wrapper = TaskWrapper(mock_app, long_coro())
+
+        # Task should be running
+        assert not wrapper.task.done()
+
+        wrapper.cancel()
+
+        # Give it a moment to be cancelled
+        await asyncio.sleep(0.01)
+
+        assert wrapper.task.done()
+        assert wrapper.task.cancelled()
+
+
+class TestAsyncTaskManager:
+    """Tests for AsyncTaskManager class."""
+
+    @pytest.mark.asyncio
+    async def test_create_task_adds_to_list(self):
+        """Test that create_task adds task to tasks list."""
+        _, _, AsyncTaskManager = get_taskmgr_classes()
+        mock_app = create_mock_app()
+
+        manager = AsyncTaskManager(mock_app)
+
+        async def dummy_coro():
+            await asyncio.sleep(0.01)
+            return 'done'
+
+        wrapper = manager.create_task(dummy_coro())
+
+        assert wrapper in manager.tasks
+        assert len(manager.tasks) == 1
+
+        wrapper.cancel()
+
+    @pytest.mark.asyncio
+    async def test_get_stats_counts_correctly(self):
+        """Test get_stats returns correct counts."""
+        _, _, AsyncTaskManager = get_taskmgr_classes()
+        mock_app = create_mock_app()
+
+        manager = AsyncTaskManager(mock_app)
+
+        async def immediate_coro():
+            return 'done'
+
+        async def delayed_coro():
+            await asyncio.sleep(0.1)
+            return 'done'
+
+        # Create tasks
+        w1 = manager.create_task(immediate_coro())
+        w2 = manager.create_task(delayed_coro())
+
+        # Wait for first to complete
+        await w1.task
+
+        stats = manager.get_stats()
+
+        assert stats['total'] == 2
+        assert stats['completed'] == 1
+        assert stats['running'] == 1
+
+        w2.cancel()
+
+    @pytest.mark.asyncio
+    async def test_get_tasks_dict_filters_by_type(self):
+        """Test get_tasks_dict filters by type."""
+        _, _, AsyncTaskManager = get_taskmgr_classes()
+        mock_app = create_mock_app()
+
+        manager = AsyncTaskManager(mock_app)
+
+        async def dummy_coro():
+            await asyncio.sleep(0.01)
+
+        # Create system and user tasks
+        w1 = manager.create_task(dummy_coro(), task_type='system')
+        w2 = manager.create_task(dummy_coro(), task_type='user')
+        w3 = manager.create_task(dummy_coro(), task_type='user')
+
+        result = manager.get_tasks_dict(type='user')
+
+        assert len(result['tasks']) == 2
+        for t in result['tasks']:
+            assert t['task_type'] == 'user'
+
+        w1.cancel()
+        w2.cancel()
+        w3.cancel()
+
+    @pytest.mark.asyncio
+    async def test_cancel_by_scope(self):
+        """Test cancel_by_scope cancels matching tasks."""
+        _, _, AsyncTaskManager = get_taskmgr_classes()
+
+        mock_app = create_mock_app()
+        manager = AsyncTaskManager(mock_app)
+
+        async def long_coro():
+            await asyncio.sleep(10)
+
+        # Create task with APPLICATION scope
+        w1 = manager.create_task(long_coro(), scopes=[MockLifecycleControlScope.APPLICATION])
+
+        # Create task with different scope
+        w2 = manager.create_task(long_coro(), scopes=[MockLifecycleControlScope.PIPELINE])
+
+        manager.cancel_by_scope(MockLifecycleControlScope.APPLICATION)
+
+        await asyncio.sleep(0.01)
+
+        assert w1.task.cancelled() or w1.task.done()
+        assert not w2.task.done()
+
+        w2.cancel()
+
+    @pytest.mark.asyncio
+    async def test_cancel_task_by_id(self):
+        """Test cancel_task cancels specific task by ID."""
+        _, _, AsyncTaskManager = get_taskmgr_classes()
+        mock_app = create_mock_app()
+
+        manager = AsyncTaskManager(mock_app)
+
+        async def long_coro():
+            await asyncio.sleep(10)
+
+        w1 = manager.create_task(long_coro())
+        w2 = manager.create_task(long_coro())
+
+        manager.cancel_task(w1.id)
+
+        await asyncio.sleep(0.01)
+
+        assert w1.task.done()
+        assert not w2.task.done()
+
+        w2.cancel()
+
+    @pytest.mark.asyncio
+    async def test_create_user_task_sets_user_type(self):
+        """Test create_user_task sets task_type to 'user'."""
+        _, _, AsyncTaskManager = get_taskmgr_classes()
+        mock_app = create_mock_app()
+
+        manager = AsyncTaskManager(mock_app)
+
+        async def dummy_coro():
+            await asyncio.sleep(0.01)
+
+        wrapper = manager.create_user_task(dummy_coro())
+
+        assert wrapper.task_type == 'user'
+
+        wrapper.cancel()
+
+    @pytest.mark.asyncio
+    async def test_get_task_by_id(self):
+        """Test get_task_by_id returns correct task."""
+        _, _, AsyncTaskManager = get_taskmgr_classes()
+        mock_app = create_mock_app()
+
+        manager = AsyncTaskManager(mock_app)
+
+        async def dummy_coro():
+            await asyncio.sleep(0.01)
+
+        w1 = manager.create_task(dummy_coro())
+        w2 = manager.create_task(dummy_coro())
+
+        found = manager.get_task_by_id(w1.id)
+        assert found is w1
+
+        not_found = manager.get_task_by_id(9999)
+        assert not_found is None
+
+        w1.cancel()
+        w2.cancel()