refactor: break up lifespan() into focused helpers

Extract _init_services(), _auto_prune(), _register_error_recorder(),
and _shutdown() from the 142-line lifespan() context manager, reducing
it to ~25 lines that read as a clear startup/shutdown sequence.

Fixes #514

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

src/dashboard/app.py

@@ -329,35 +329,21 @@ async def _discord_token_watcher() -> None:
                 logger.warning("Discord auto-start failed: %s", exc)
 
 
-def _startup_init() -> None:
-    """Validate config and enable event persistence."""
+def _init_services() -> None:
+    """Validate config, enable event persistence, and init Spark engine."""
     from config import validate_startup
+    from infrastructure.events.bus import init_event_bus_persistence
+    from spark.engine import get_spark_engine
 
     validate_startup()
-
-    from infrastructure.events.bus import init_event_bus_persistence
-
     init_event_bus_persistence()
 
-    from spark.engine import get_spark_engine
-
     if get_spark_engine().enabled:
         logger.info("Spark Intelligence active — event capture enabled")
 
 
-def _startup_background_tasks() -> list[asyncio.Task]:
-    """Spawn all recurring background tasks (non-blocking)."""
-    return [
-        asyncio.create_task(_briefing_scheduler()),
-        asyncio.create_task(_thinking_scheduler()),
-        asyncio.create_task(_loop_qa_scheduler()),
-        asyncio.create_task(_presence_watcher()),
-        asyncio.create_task(_start_chat_integrations_background()),
-    ]
-
-
-def _startup_pruning() -> None:
-    """Auto-prune old memories, thoughts, and events on startup."""
+def _auto_prune() -> None:
+    """Run startup housekeeping: prune memories, thoughts, events, and check vault size."""
     if settings.memory_prune_days > 0:
         try:
             from timmy.memory_system import prune_memories
@@ -425,11 +411,22 @@ def _startup_pruning() -> None:
             logger.debug("Vault size check skipped: %s", exc)
 
 
-async def _shutdown_cleanup(
-    bg_tasks: list[asyncio.Task],
-    workshop_heartbeat,
+def _register_error_recorder() -> None:
+    """Wire the session logger into the error-capture system."""
+    try:
+        from infrastructure.error_capture import register_error_recorder
+        from timmy.session_logger import get_session_logger
+
+        register_error_recorder(get_session_logger().record_error)
+    except Exception:
+        logger.debug("Failed to register error recorder")
+
+
+async def _shutdown(
+    tasks: list[asyncio.Task],
+    workshop_heartbeat: object,
 ) -> None:
-    """Stop chat bots, MCP sessions, heartbeat, and cancel background tasks."""
+    """Stop integrations, close sessions, and cancel background tasks."""
     from integrations.chat_bridge.vendors.discord import discord_bot
     from integrations.telegram_bot.bot import telegram_bot
 
@@ -443,9 +440,9 @@ async def _shutdown_cleanup(
     except Exception as exc:
         logger.debug("MCP shutdown: %s", exc)
 
-    await workshop_heartbeat.stop()
+    await workshop_heartbeat.stop()  # type: ignore[union-attr]
 
-    for task in bg_tasks:
+    for task in tasks:
         task.cancel()
         try:
             await task
@@ -456,9 +453,16 @@ async def _shutdown_cleanup(
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     """Application lifespan manager with non-blocking startup."""
-    _startup_init()
-    bg_tasks = _startup_background_tasks()
-    _startup_pruning()
+    _init_services()
+    _auto_prune()
+
+    # Create all background tasks without waiting for them
+    bg_tasks = [
+        asyncio.create_task(_briefing_scheduler()),
+        asyncio.create_task(_thinking_scheduler()),
+        asyncio.create_task(_loop_qa_scheduler()),
+        asyncio.create_task(_presence_watcher()),
+    ]
 
     # Start Workshop presence heartbeat with WS relay
     from dashboard.routes.world import broadcast_world_state
@@ -467,20 +471,15 @@ async def lifespan(app: FastAPI):
     workshop_heartbeat = WorkshopHeartbeat(on_change=broadcast_world_state)
     await workshop_heartbeat.start()
 
-    # Register session logger with error capture
-    try:
-        from infrastructure.error_capture import register_error_recorder
-        from timmy.session_logger import get_session_logger
-
-        register_error_recorder(get_session_logger().record_error)
-    except Exception:
-        logger.debug("Failed to register error recorder")
+    # Start chat integrations in background
+    bg_tasks.append(asyncio.create_task(_start_chat_integrations_background()))
 
+    _register_error_recorder()
     logger.info("✓ Dashboard ready for requests")
 
     yield
 
-    await _shutdown_cleanup(bg_tasks, workshop_heartbeat)
+    await _shutdown(bg_tasks, workshop_heartbeat)
 
 
 app = FastAPI(

src/infrastructure/error_capture.py

@@ -100,25 +100,48 @@ def _get_git_context() -> dict:
         return {"branch": "unknown", "commit": "unknown"}
 
 
-def _extract_origin(exc: Exception) -> tuple[str, int]:
-    """Walk the traceback to find the deepest file and line number."""
+def capture_error(
+    exc: Exception,
+    source: str = "unknown",
+    context: dict | None = None,
+) -> str | None:
+    """Capture an error and optionally create a bug report.
+
+    Args:
+        exc: The exception to capture
+        source: Module/component where the error occurred
+        context: Optional dict of extra context (request path, etc.)
+
+    Returns:
+        Task ID of the created bug report, or None if deduplicated/disabled
+    """
+    from config import settings
+
+    if not settings.error_feedback_enabled:
+        return None
+
+    error_hash = _stack_hash(exc)
+
+    if _is_duplicate(error_hash):
+        logger.debug("Duplicate error suppressed: %s (hash=%s)", exc, error_hash)
+        return None
+
+    # Format the stack trace
+    tb_str = "".join(traceback.format_exception(type(exc), exc, exc.__traceback__))
+
+    # Extract file/line from traceback
     tb_obj = exc.__traceback__
+    affected_file = "unknown"
+    affected_line = 0
     while tb_obj and tb_obj.tb_next:
         tb_obj = tb_obj.tb_next
     if tb_obj:
-        return tb_obj.tb_frame.f_code.co_filename, tb_obj.tb_lineno
-    return "unknown", 0
+        affected_file = tb_obj.tb_frame.f_code.co_filename
+        affected_line = tb_obj.tb_lineno
 
+    git_ctx = _get_git_context()
 
-def _log_error_event(
-    exc: Exception,
-    source: str,
-    error_hash: str,
-    affected_file: str,
-    affected_line: int,
-    git_ctx: dict,
-) -> None:
-    """Log the error to the event log (best-effort)."""
+    # 1. Log to event_log
     try:
         from swarm.event_log import EventType, log_event
 
@@ -138,18 +161,8 @@ def _log_error_event(
     except Exception as log_exc:
         logger.debug("Failed to log error event: %s", log_exc)
 
-
-def _create_bug_report(
-    exc: Exception,
-    source: str,
-    error_hash: str,
-    affected_file: str,
-    affected_line: int,
-    git_ctx: dict,
-    tb_str: str,
-    context: dict | None,
-) -> str | None:
-    """Create a bug report task and return its ID (best-effort)."""
+    # 2. Create bug report task
+    task_id = None
     try:
         from swarm.task_queue.models import create_task
 
@@ -180,30 +193,29 @@ def _create_bug_report(
             auto_approve=True,
             task_type="bug_report",
         )
+        task_id = task.id
 
+        # Log the creation event
         try:
             from swarm.event_log import EventType, log_event
 
             log_event(
                 EventType.BUG_REPORT_CREATED,
                 source=source,
-                task_id=task.id,
+                task_id=task_id,
                 data={
                     "error_hash": error_hash,
                     "title": title[:100],
                 },
             )
-        except Exception as log_exc:
-            logger.warning("Bug report log error: %s", log_exc)
+        except Exception as exc:
+            logger.warning("Bug report screenshot error: %s", exc)
+            pass
 
-        return task.id
     except Exception as task_exc:
         logger.debug("Failed to create bug report task: %s", task_exc)
-        return None
 
-
-def _send_error_notification(exc: Exception, source: str) -> None:
-    """Push a notification about the captured error (best-effort)."""
+    # 3. Send notification
     try:
         from infrastructure.notifications.push import notifier
 
@@ -212,12 +224,11 @@ def _send_error_notification(exc: Exception, source: str) -> None:
             message=f"{type(exc).__name__} in {source}: {str(exc)[:80]}",
             category="system",
         )
-    except Exception as notify_exc:
-        logger.warning("Bug report notification error: %s", notify_exc)
+    except Exception as exc:
+        logger.warning("Bug report notification error: %s", exc)
+        pass
 
-
-def _record_to_session(exc: Exception, source: str) -> None:
-    """Forward the error to the registered session recorder (best-effort)."""
+    # 4. Record in session logger (via registered callback)
     if _error_recorder is not None:
         try:
             _error_recorder(
@@ -227,44 +238,4 @@ def _record_to_session(exc: Exception, source: str) -> None:
         except Exception as log_exc:
             logger.warning("Bug report session logging error: %s", log_exc)
 
-
-def capture_error(
-    exc: Exception,
-    source: str = "unknown",
-    context: dict | None = None,
-) -> str | None:
-    """Capture an error and optionally create a bug report.
-
-    Args:
-        exc: The exception to capture
-        source: Module/component where the error occurred
-        context: Optional dict of extra context (request path, etc.)
-
-    Returns:
-        Task ID of the created bug report, or None if deduplicated/disabled
-    """
-    from config import settings
-
-    if not settings.error_feedback_enabled:
-        return None
-
-    error_hash = _stack_hash(exc)
-
-    if _is_duplicate(error_hash):
-        logger.debug("Duplicate error suppressed: %s (hash=%s)", exc, error_hash)
-        return None
-
-    tb_str = "".join(traceback.format_exception(type(exc), exc, exc.__traceback__))
-    affected_file, affected_line = _extract_origin(exc)
-    git_ctx = _get_git_context()
-
-    _log_error_event(exc, source, error_hash, affected_file, affected_line, git_ctx)
-
-    task_id = _create_bug_report(
-        exc, source, error_hash, affected_file, affected_line, git_ctx, tb_str, context
-    )
-
-    _send_error_notification(exc, source)
-    _record_to_session(exc, source)
-
     return task_id

src/timmy/agent.py

@@ -197,90 +197,6 @@ def _resolve_backend(requested: str | None) -> str:
     return "ollama"
 
 
-def _build_tools_list(use_tools: bool, skip_mcp: bool, model_name: str) -> list:
-    """Assemble the tools list based on model capability and MCP flags.
-
-    Returns a list of Toolkit / MCPTools objects, or an empty list.
-    """
-    if not use_tools:
-        logger.info("Tools disabled for model %s (too small for reliable tool calling)", model_name)
-        return []
-
-    tools_list: list = [create_full_toolkit()]
-
-    # Add MCP tool servers (lazy-connected on first arun()).
-    # Skipped when skip_mcp=True — MCP's stdio transport uses anyio cancel
-    # scopes that conflict with asyncio background task cancellation (#72).
-    if not skip_mcp:
-        try:
-            from timmy.mcp_tools import create_filesystem_mcp_tools, create_gitea_mcp_tools
-
-            gitea_mcp = create_gitea_mcp_tools()
-            if gitea_mcp:
-                tools_list.append(gitea_mcp)
-
-            fs_mcp = create_filesystem_mcp_tools()
-            if fs_mcp:
-                tools_list.append(fs_mcp)
-        except Exception as exc:
-            logger.debug("MCP tools unavailable: %s", exc)
-
-    return tools_list
-
-
-def _build_prompt(use_tools: bool, session_id: str) -> str:
-    """Build the full system prompt with optional memory context."""
-    base_prompt = get_system_prompt(tools_enabled=use_tools, session_id=session_id)
-
-    try:
-        from timmy.memory_system import memory_system
-
-        memory_context = memory_system.get_system_context()
-        if memory_context:
-            # Smaller budget for small models — expanded prompt uses more tokens
-            max_context = 2000 if not use_tools else 8000
-            if len(memory_context) > max_context:
-                memory_context = memory_context[:max_context] + "\n... [truncated]"
-            return (
-                f"{base_prompt}\n\n"
-                f"## GROUNDED CONTEXT (verified sources — cite when using)\n\n"
-                f"{memory_context}"
-            )
-    except Exception as exc:
-        logger.warning("Failed to load memory context: %s", exc)
-
-    return base_prompt
-
-
-def _create_ollama_agent(
-    *,
-    db_file: str,
-    model_name: str,
-    tools_list: list,
-    full_prompt: str,
-    use_tools: bool,
-) -> Agent:
-    """Construct the Agno Agent with Ollama backend and warm up the model."""
-    model_kwargs = {}
-    if settings.ollama_num_ctx > 0:
-        model_kwargs["options"] = {"num_ctx": settings.ollama_num_ctx}
-
-    agent = Agent(
-        name="Agent",
-        model=Ollama(id=model_name, host=settings.ollama_url, timeout=300, **model_kwargs),
-        db=SqliteDb(db_file=db_file),
-        description=full_prompt,
-        add_history_to_context=True,
-        num_history_runs=20,
-        markdown=False,
-        tools=tools_list if tools_list else None,
-        tool_call_limit=settings.max_agent_steps if use_tools else None,
-        telemetry=settings.telemetry_enabled,
-    )
-    _warmup_model(model_name)
-    return agent
-
-
 def create_timmy(
     db_file: str = "timmy.db",
     backend: str | None = None,
@@ -322,12 +238,16 @@ def create_timmy(
         return TimmyAirLLMAgent(model_size=size)
 
     # Default: Ollama via Agno.
+    # Resolve model with automatic pulling and fallback
     model_name, is_fallback = _resolve_model_with_fallback(
         requested_model=None,
         require_vision=False,
         auto_pull=True,
     )
 
+    # If Ollama is completely unreachable, fail loudly.
+    # Sovereignty: never silently send data to a cloud API.
+    # Use --backend claude explicitly if you want cloud inference.
     if not _check_model_available(model_name):
         logger.error(
             "Ollama unreachable and no local models available. "
@@ -338,16 +258,76 @@ def create_timmy(
         logger.info("Using fallback model %s (requested was unavailable)", model_name)
 
     use_tools = _model_supports_tools(model_name)
-    tools_list = _build_tools_list(use_tools, skip_mcp, model_name)
-    full_prompt = _build_prompt(use_tools, session_id)
 
-    return _create_ollama_agent(
-        db_file=db_file,
-        model_name=model_name,
-        tools_list=tools_list,
-        full_prompt=full_prompt,
-        use_tools=use_tools,
+    # Conditionally include tools — small models get none
+    toolkit = create_full_toolkit() if use_tools else None
+    if not use_tools:
+        logger.info("Tools disabled for model %s (too small for reliable tool calling)", model_name)
+
+    # Build the tools list — Agno accepts a list of Toolkit / MCPTools
+    tools_list: list = []
+    if toolkit:
+        tools_list.append(toolkit)
+
+    # Add MCP tool servers (lazy-connected on first arun()).
+    # Skipped when skip_mcp=True — MCP's stdio transport uses anyio cancel
+    # scopes that conflict with asyncio background task cancellation (#72).
+    if use_tools and not skip_mcp:
+        try:
+            from timmy.mcp_tools import create_filesystem_mcp_tools, create_gitea_mcp_tools
+
+            gitea_mcp = create_gitea_mcp_tools()
+            if gitea_mcp:
+                tools_list.append(gitea_mcp)
+
+            fs_mcp = create_filesystem_mcp_tools()
+            if fs_mcp:
+                tools_list.append(fs_mcp)
+        except Exception as exc:
+            logger.debug("MCP tools unavailable: %s", exc)
+
+    # Select prompt tier based on tool capability
+    base_prompt = get_system_prompt(tools_enabled=use_tools, session_id=session_id)
+
+    # Try to load memory context
+    try:
+        from timmy.memory_system import memory_system
+
+        memory_context = memory_system.get_system_context()
+        if memory_context:
+            # Truncate if too long — smaller budget for small models
+            # since the expanded prompt (roster, guardrails) uses more tokens
+            max_context = 2000 if not use_tools else 8000
+            if len(memory_context) > max_context:
+                memory_context = memory_context[:max_context] + "\n... [truncated]"
+            full_prompt = (
+                f"{base_prompt}\n\n"
+                f"## GROUNDED CONTEXT (verified sources — cite when using)\n\n"
+                f"{memory_context}"
+            )
+        else:
+            full_prompt = base_prompt
+    except Exception as exc:
+        logger.warning("Failed to load memory context: %s", exc)
+        full_prompt = base_prompt
+
+    model_kwargs = {}
+    if settings.ollama_num_ctx > 0:
+        model_kwargs["options"] = {"num_ctx": settings.ollama_num_ctx}
+    agent = Agent(
+        name="Agent",
+        model=Ollama(id=model_name, host=settings.ollama_url, timeout=300, **model_kwargs),
+        db=SqliteDb(db_file=db_file),
+        description=full_prompt,
+        add_history_to_context=True,
+        num_history_runs=20,
+        markdown=False,
+        tools=tools_list if tools_list else None,
+        tool_call_limit=settings.max_agent_steps if use_tools else None,
+        telemetry=settings.telemetry_enabled,
     )
+    _warmup_model(model_name)
+    return agent
 
 
 class TimmyWithMemory:

src/timmy/thinking.py

@@ -232,90 +232,6 @@ class ThinkingEngine:
             return False  # Disabled — never idle
         return datetime.now(UTC) - self._last_input_time > timedelta(minutes=timeout)
 
-    def _build_thinking_context(self) -> tuple[str, str, list["Thought"]]:
-        """Assemble the context needed for a thinking cycle.
-
-        Returns:
-            (memory_context, system_context, recent_thoughts)
-        """
-        memory_context = self._load_memory_context()
-        system_context = self._gather_system_snapshot()
-        recent_thoughts = self.get_recent_thoughts(limit=5)
-        return memory_context, system_context, recent_thoughts
-
-    async def _generate_novel_thought(
-        self,
-        prompt: str | None,
-        memory_context: str,
-        system_context: str,
-        recent_thoughts: list["Thought"],
-    ) -> tuple[str | None, str]:
-        """Run the dedup-retry loop to produce a novel thought.
-
-        Returns:
-            (content, seed_type) — content is None if no novel thought produced.
-        """
-        seed_type: str = "freeform"
-
-        for attempt in range(self._MAX_DEDUP_RETRIES + 1):
-            if prompt:
-                seed_type = "prompted"
-                seed_context = f"Journal prompt: {prompt}"
-            else:
-                seed_type, seed_context = self._gather_seed()
-
-            continuity = self._build_continuity_context()
-
-            full_prompt = _THINKING_PROMPT.format(
-                memory_context=memory_context,
-                system_context=system_context,
-                seed_context=seed_context,
-                continuity_context=continuity,
-            )
-
-            try:
-                raw = await self._call_agent(full_prompt)
-            except Exception as exc:
-                logger.warning("Thinking cycle failed (Ollama likely down): %s", exc)
-                return None, seed_type
-
-            if not raw or not raw.strip():
-                logger.debug("Thinking cycle produced empty response, skipping")
-                return None, seed_type
-
-            content = raw.strip()
-
-            # Dedup: reject thoughts too similar to recent ones
-            if not self._is_too_similar(content, recent_thoughts):
-                return content, seed_type  # Good — novel thought
-
-            if attempt < self._MAX_DEDUP_RETRIES:
-                logger.info(
-                    "Thought too similar to recent (attempt %d/%d), retrying with new seed",
-                    attempt + 1,
-                    self._MAX_DEDUP_RETRIES + 1,
-                )
-            else:
-                logger.warning(
-                    "Thought still repetitive after %d retries, discarding",
-                    self._MAX_DEDUP_RETRIES + 1,
-                )
-                return None, seed_type
-
-        return None, seed_type
-
-    async def _process_thinking_result(self, thought: "Thought") -> None:
-        """Run all post-hooks after a thought is stored."""
-        self._maybe_check_memory()
-        await self._maybe_distill()
-        await self._maybe_file_issues()
-        await self._check_workspace()
-        self._maybe_check_memory_status()
-        self._update_memory(thought)
-        self._log_event(thought)
-        self._write_journal(thought)
-        await self._broadcast(thought)
-
     async def think_once(self, prompt: str | None = None) -> Thought | None:
         """Execute one thinking cycle.
 
@@ -341,21 +257,91 @@ class ThinkingEngine:
             )
             return None
 
-        memory_context, system_context, recent_thoughts = self._build_thinking_context()
+        memory_context = self._load_memory_context()
+        system_context = self._gather_system_snapshot()
+        recent_thoughts = self.get_recent_thoughts(limit=5)
+
+        content: str | None = None
+        seed_type: str = "freeform"
+
+        for attempt in range(self._MAX_DEDUP_RETRIES + 1):
+            if prompt:
+                seed_type = "prompted"
+                seed_context = f"Journal prompt: {prompt}"
+            else:
+                seed_type, seed_context = self._gather_seed()
+
+            continuity = self._build_continuity_context()
+
+            full_prompt = _THINKING_PROMPT.format(
+                memory_context=memory_context,
+                system_context=system_context,
+                seed_context=seed_context,
+                continuity_context=continuity,
+            )
+
+            try:
+                raw = await self._call_agent(full_prompt)
+            except Exception as exc:
+                logger.warning("Thinking cycle failed (Ollama likely down): %s", exc)
+                return None
+
+            if not raw or not raw.strip():
+                logger.debug("Thinking cycle produced empty response, skipping")
+                return None
+
+            content = raw.strip()
+
+            # Dedup: reject thoughts too similar to recent ones
+            if not self._is_too_similar(content, recent_thoughts):
+                break  # Good — novel thought
+
+            if attempt < self._MAX_DEDUP_RETRIES:
+                logger.info(
+                    "Thought too similar to recent (attempt %d/%d), retrying with new seed",
+                    attempt + 1,
+                    self._MAX_DEDUP_RETRIES + 1,
+                )
+                content = None  # Will retry
+            else:
+                logger.warning(
+                    "Thought still repetitive after %d retries, discarding",
+                    self._MAX_DEDUP_RETRIES + 1,
+                )
+                return None
 
-        content, seed_type = await self._generate_novel_thought(
-            prompt,
-            memory_context,
-            system_context,
-            recent_thoughts,
-        )
         if not content:
             return None
 
         thought = self._store_thought(content, seed_type)
         self._last_thought_id = thought.id
 
-        await self._process_thinking_result(thought)
+        # Post-hook: check memory status periodically
+        self._maybe_check_memory()
+
+        # Post-hook: distill facts from recent thoughts periodically
+        await self._maybe_distill()
+
+        # Post-hook: file Gitea issues for actionable observations
+        await self._maybe_file_issues()
+
+        # Post-hook: check workspace for new messages from Hermes
+        await self._check_workspace()
+
+        # Post-hook: proactive memory status audit
+        self._maybe_check_memory_status()
+
+        # Post-hook: update MEMORY.md with latest reflection
+        self._update_memory(thought)
+
+        # Log to swarm event system
+        self._log_event(thought)
+
+        # Append to daily journal file
+        self._write_journal(thought)
+
+        # Broadcast to WebSocket clients
+        await self._broadcast(thought)
 
         logger.info(
             "Thought [%s] (%s): %s",

tests/infrastructure/test_error_capture.py

@@ -5,14 +5,9 @@ from datetime import UTC, datetime, timedelta
 from unittest.mock import patch
 
 from infrastructure.error_capture import (
-    _create_bug_report,
     _dedup_cache,
-    _extract_origin,
     _get_git_context,
     _is_duplicate,
-    _log_error_event,
-    _record_to_session,
-    _send_error_notification,
     _stack_hash,
     capture_error,
 )
@@ -198,87 +193,3 @@ class TestCaptureError:
 
     def teardown_method(self):
         _dedup_cache.clear()
-
-
-class TestExtractOrigin:
-    """Test _extract_origin helper."""
-
-    def test_returns_file_and_line(self):
-        try:
-            _make_exception()
-        except ValueError as e:
-            filename, lineno = _extract_origin(e)
-        assert filename.endswith("test_error_capture.py")
-        assert lineno > 0
-
-    def test_no_traceback_returns_defaults(self):
-        exc = ValueError("no tb")
-        exc.__traceback__ = None
-        assert _extract_origin(exc) == ("unknown", 0)
-
-
-class TestLogErrorEvent:
-    """Test _log_error_event helper."""
-
-    def test_does_not_crash_when_event_log_missing(self):
-        try:
-            raise RuntimeError("log test")
-        except RuntimeError as e:
-            _log_error_event(e, "test", "abc123", "file.py", 42, {})
-
-
-class TestCreateBugReport:
-    """Test _create_bug_report helper."""
-
-    def test_returns_none_on_import_failure(self):
-        try:
-            raise RuntimeError("report test")
-        except RuntimeError as e:
-            with patch("infrastructure.error_capture.logger"):
-                result = _create_bug_report(e, "test", "abc", "f.py", 1, {}, "tb", None)
-        # Returns a task id or None depending on whether swarm is available
-        assert result is None or isinstance(result, str)
-
-
-class TestSendErrorNotification:
-    """Test _send_error_notification helper."""
-
-    def test_does_not_crash_on_notifier_failure(self):
-        try:
-            raise RuntimeError("notify test")
-        except RuntimeError as e:
-            _send_error_notification(e, "test")
-
-
-class TestRecordToSession:
-    """Test _record_to_session helper."""
-
-    def test_noop_when_no_recorder(self):
-        import infrastructure.error_capture as ec
-
-        original = ec._error_recorder
-        try:
-            ec._error_recorder = None
-            try:
-                raise RuntimeError("session test")
-            except RuntimeError as e:
-                _record_to_session(e, "test")  # should not crash
-        finally:
-            ec._error_recorder = original
-
-    def test_calls_registered_recorder(self):
-        import infrastructure.error_capture as ec
-
-        original = ec._error_recorder
-        calls = []
-        try:
-            ec._error_recorder = lambda **kwargs: calls.append(kwargs)
-            try:
-                raise RuntimeError("recorded")
-            except RuntimeError as e:
-                _record_to_session(e, "src")
-            assert len(calls) == 1
-            assert "RuntimeError: recorded" in calls[0]["error"]
-            assert calls[0]["context"] == "src"
-        finally:
-            ec._error_recorder = original

tests/timmy/test_agent.py

@@ -444,150 +444,6 @@ def test_get_effective_ollama_model_walks_fallback_chain():
         assert result == "fb-2"
 
 
-# ── _build_tools_list ─────────────────────────────────────────────────────
-
-
-def test_build_tools_list_empty_when_tools_disabled():
-    """Small models get an empty tools list."""
-    from timmy.agent import _build_tools_list
-
-    result = _build_tools_list(use_tools=False, skip_mcp=False, model_name="llama3.2")
-    assert result == []
-
-
-def test_build_tools_list_includes_toolkit_when_enabled():
-    """Tool-capable models get the full toolkit."""
-    mock_toolkit = MagicMock()
-    with patch("timmy.agent.create_full_toolkit", return_value=mock_toolkit):
-        from timmy.agent import _build_tools_list
-
-        result = _build_tools_list(use_tools=True, skip_mcp=True, model_name="llama3.1")
-        assert mock_toolkit in result
-
-
-def test_build_tools_list_skips_mcp_when_flagged():
-    """skip_mcp=True must not call MCP factories."""
-    mock_toolkit = MagicMock()
-    with (
-        patch("timmy.agent.create_full_toolkit", return_value=mock_toolkit),
-        patch("timmy.mcp_tools.create_gitea_mcp_tools") as mock_gitea,
-        patch("timmy.mcp_tools.create_filesystem_mcp_tools") as mock_fs,
-    ):
-        from timmy.agent import _build_tools_list
-
-        _build_tools_list(use_tools=True, skip_mcp=True, model_name="llama3.1")
-        mock_gitea.assert_not_called()
-        mock_fs.assert_not_called()
-
-
-def test_build_tools_list_includes_mcp_when_not_skipped():
-    """skip_mcp=False should attempt MCP tool creation."""
-    mock_toolkit = MagicMock()
-    with (
-        patch("timmy.agent.create_full_toolkit", return_value=mock_toolkit),
-        patch("timmy.mcp_tools.create_gitea_mcp_tools", return_value=None) as mock_gitea,
-        patch("timmy.mcp_tools.create_filesystem_mcp_tools", return_value=None) as mock_fs,
-    ):
-        from timmy.agent import _build_tools_list
-
-        _build_tools_list(use_tools=True, skip_mcp=False, model_name="llama3.1")
-        mock_gitea.assert_called_once()
-        mock_fs.assert_called_once()
-
-
-# ── _build_prompt ─────────────────────────────────────────────────────────
-
-
-def test_build_prompt_includes_base_prompt():
-    """Prompt should always contain the base system prompt."""
-    from timmy.agent import _build_prompt
-
-    result = _build_prompt(use_tools=False, session_id="test")
-    assert "Timmy" in result
-
-
-def test_build_prompt_appends_memory_context():
-    """Memory context should be appended when available."""
-    mock_memory = MagicMock()
-    mock_memory.get_system_context.return_value = "User prefers dark mode."
-    with patch("timmy.memory_system.memory_system", mock_memory):
-        from timmy.agent import _build_prompt
-
-        result = _build_prompt(use_tools=True, session_id="test")
-        assert "GROUNDED CONTEXT" in result
-        assert "dark mode" in result
-
-
-def test_build_prompt_truncates_long_memory():
-    """Long memory context should be truncated."""
-    mock_memory = MagicMock()
-    mock_memory.get_system_context.return_value = "x" * 10000
-    with patch("timmy.memory_system.memory_system", mock_memory):
-        from timmy.agent import _build_prompt
-
-        result = _build_prompt(use_tools=False, session_id="test")
-        assert "[truncated]" in result
-
-
-def test_build_prompt_survives_memory_failure():
-    """Prompt should fall back to base when memory fails."""
-    mock_memory = MagicMock()
-    mock_memory.get_system_context.side_effect = RuntimeError("db locked")
-    with patch("timmy.memory_system.memory_system", mock_memory):
-        from timmy.agent import _build_prompt
-
-        result = _build_prompt(use_tools=True, session_id="test")
-        assert "Timmy" in result
-        # Memory context should NOT be appended (the db locked error was caught)
-        assert "db locked" not in result
-
-
-# ── _create_ollama_agent ──────────────────────────────────────────────────
-
-
-def test_create_ollama_agent_passes_correct_kwargs():
-    """_create_ollama_agent must pass the expected kwargs to Agent."""
-    with (
-        patch("timmy.agent.Agent") as MockAgent,
-        patch("timmy.agent.Ollama"),
-        patch("timmy.agent.SqliteDb"),
-        patch("timmy.agent._warmup_model", return_value=True),
-    ):
-        from timmy.agent import _create_ollama_agent
-
-        _create_ollama_agent(
-            db_file="test.db",
-            model_name="llama3.1",
-            tools_list=[MagicMock()],
-            full_prompt="test prompt",
-            use_tools=True,
-        )
-        kwargs = MockAgent.call_args.kwargs
-        assert kwargs["description"] == "test prompt"
-        assert kwargs["markdown"] is False
-
-
-def test_create_ollama_agent_none_tools_when_empty():
-    """Empty tools_list should pass tools=None to Agent."""
-    with (
-        patch("timmy.agent.Agent") as MockAgent,
-        patch("timmy.agent.Ollama"),
-        patch("timmy.agent.SqliteDb"),
-        patch("timmy.agent._warmup_model", return_value=True),
-    ):
-        from timmy.agent import _create_ollama_agent
-
-        _create_ollama_agent(
-            db_file="test.db",
-            model_name="llama3.2",
-            tools_list=[],
-            full_prompt="test prompt",
-            use_tools=False,
-        )
-        kwargs = MockAgent.call_args.kwargs
-        assert kwargs["tools"] is None
-
-
 def test_no_hardcoded_fallback_constants_in_agent():
     """agent.py must not define module-level DEFAULT_MODEL_FALLBACKS."""
     import timmy.agent as agent_mod