diff --git a/.run/ManualTests.run.xml b/.run/ManualTests.run.xml
new file mode 100644
index 00000000..6c737b18
--- /dev/null
+++ b/.run/ManualTests.run.xml
@@ -0,0 +1,13 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="ManualTests" type="JUnit" factoryName="JUnit">
+    <module name="opendaimon-app" />
+    <option name="MAIN_CLASS_NAME" value="" />
+    <option name="METHOD_NAME" value="" />
+    <option name="TEST_OBJECT" value="directory" />
+    <option name="VM_PARAMETERS" value="-ea -Dmanual.ollama.e2e=true -Dmanual.openrouter.e2e=true" />
+    <dir value="$PROJECT_DIR$/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual" />
+    <method v="2">
+      <option name="Make" enabled="true" />
+    </method>
+  </configuration>
+</component>
\ No newline at end of file
diff --git a/.serena/memories/handoff/module-hygiene-dependency-analyze-2026-04-30.md b/.serena/memories/handoff/module-hygiene-dependency-analyze-2026-04-30.md
new file mode 100644
index 00000000..92a7971c
--- /dev/null
+++ b/.serena/memories/handoff/module-hygiene-dependency-analyze-2026-04-30.md
@@ -0,0 +1,165 @@
+# Handoff: module hygiene / dependency analyze / ArchUnit
+
+Date: 2026-04-30
+Project: open-daimon
+
+## User request
+Implement Maven Central readiness plan:
+- minimal dependency declarations per module (`declare what you use`)
+- reactor-wide `dependency:analyze`
+- wire `maven-dependency-plugin:analyze-only` into `verify` with `failOnWarning=true`
+- add ArchUnit boundary/layer rules
+- add Maven Enforcer rules: dependency convergence, upper bounds, ban commons-logging, ban Spring Boot starters in non-app modules.
+
+User then asked to split remaining work by module and persist state for a new session.
+
+## Important project constraints
+- Do not revert unrelated user/AI dirty changes.
+- Public APIs matter. Avoid public type/method removals/renames unless explicitly approved.
+- Modules are published/consumed independently; each module must declare directly-used libraries even if transitively available.
+- No `@Service`, `@Component`, `@Repository` in main sources; explicit `@Bean` config only.
+- Code/docs in repo must be English.
+
+## Dirty state known before this work
+Unrelated/generated files existed and should not be reverted unless user asks:
+- `.serena/project.yml` modified
+- docs/team files added
+- various repository interfaces had `@Repository` removed by prior work
+- some POMs were already partially edited
+
+## Completed changes
+### Root `pom.xml`
+- Spring Boot aligned to `3.5.13`.
+- Removed explicit Spring Framework BOM override.
+- Updated several managed versions:
+  - `postgresql.version=42.7.10`
+  - `flyway.version=11.7.2`
+  - `flyway-database-postgresql.version=11.7.2`
+  - `jakarta-xml-bind.version=4.0.4`
+  - `lombok.version=1.18.44`
+  - `testcontainers.version=1.21.4`
+  - `h2.version=2.3.232`
+  - `maven-dependency-plugin.version=3.8.1`
+  - `maven-enforcer-plugin.version=3.6.2`
+  - `archunit.version=1.4.2`
+- Added commons-logging exclusions to managed `httpclient` and `pdfbox`.
+- Added pluginManagement for `maven-dependency-plugin:analyze-only` bound to `verify` with `failOnWarning=true`, `ignoreNonCompile=true`, `outputXML=true`.
+- Added pluginManagement for `maven-enforcer-plugin` bound to `verify` with `dependencyConvergence`, `requireUpperBoundDeps`, and transitive banned `commons-logging:commons-logging`.
+- Activated dependency/enforcer plugins in root `<build><plugins>`.
+
+### Module POMs
+- Copied dependency-cleanup baseline POMs from `../open-daimon-2` into current repo before patching further.
+- Added module-local enforcer config banning transitive `org.springframework.boot:spring-boot-starter*` in non-app modules:
+  - `opendaimon-common`
+  - `opendaimon-spring-ai`
+  - `opendaimon-rest`
+  - `opendaimon-telegram`
+  - `opendaimon-ui`
+  - `opendaimon-gateway-mock`
+- `opendaimon-app/pom.xml`: added `com.tngtech.archunit:archunit-junit5` test dependency and analyzer ignores for ArchUnit.
+- `opendaimon-spring-ai/pom.xml`: replaced Spring AI starter runtime deps with non-starter autoconfigure deps:
+  - `spring-ai-autoconfigure-model-chat-memory`
+  - `spring-ai-autoconfigure-model-chat-memory-repository-jdbc`
+- `opendaimon-common/pom.xml`: removed unused main deps reported by analyzer:
+  - `reactor-netty-http`
+  - `hibernate-validator`
+  - `postgresql`
+  - `micrometer-registry-prometheus`
+  - `resilience4j-spring-boot2`
+
+### Code boundary changes
+Moved direct repository access out of delivery/service clients and behind services:
+- `ConversationThreadService` gained:
+  - `findThreads(ThreadScopeKind scopeKind, Long scopeId)`
+  - `closeCurrentThread(ThreadScopeKind scopeKind, Long scopeId)`
+  - existing `findByThreadKey` marked read-only transactional
+- `OpenDaimonMessageService` gained:
+  - `findByThreadOrderBySequenceNumberAsc(ConversationThread thread)`
+  - `findByThreadAndSequenceNumberGreaterThanOrderBySequenceNumberAsc(ConversationThread thread, Integer minSequenceNumber)`
+- `HistoryTelegramCommandHandler` uses `ConversationThreadService` and `OpenDaimonMessageService`.
+- `ThreadsTelegramCommandHandler` uses `ConversationThreadService.findThreads`.
+- `NewThreadTelegramCommandHandler` uses `ConversationThreadService.closeCurrentThread`.
+- `SummarizingChatMemory` uses `ConversationThreadService` and `OpenDaimonMessageService`.
+- `TelegramCommandHandlerConfig` and `SpringAIAutoConfig` wiring updated accordingly.
+
+### Tests partially updated
+- `SummarizingChatMemoryTest` updated from repository mocks to service mocks.
+- Telegram handler tests were patched but not re-verified after patch due user interrupt:
+  - `ThreadsTelegramCommandHandlerTest`: removed repository mock and uses `threadService.findThreads`.
+  - `HistoryTelegramCommandHandlerTest`: uses `ConversationThreadService` and `OpenDaimonMessageService` mocks.
+  - `NewThreadTelegramCommandHandlerTest`: removed repository mock and verifies `closeCurrentThread`.
+
+### ArchUnit
+- Deleted old frozen `ArchitectureTest` and frozen store files:
+  - `opendaimon-app/src/test/resources/archunit.properties`
+  - files under `opendaimon-app/archunit_store/`
+- Added new `opendaimon-app/src/test/java/io/github/ngirchev/opendaimon/arch/ArchitectureTest.java` with rules:
+  - no `@Service`, `@Component`, `@Repository` in common/springai/telegram/rest/ui main packages
+  - no cyclic library module dependencies
+  - telegram must not depend on rest
+  - rest must not depend on telegram
+  - only app/root package may depend on multiple delivery channels
+  - repository layer may only be accessed by service/config layers
+
+## Verification completed before interrupt
+- `./mvnw -pl opendaimon-app -am clean compile -DskipTests` passed.
+- `./mvnw dependency:analyze -DskipTests` first failed on `SummarizingChatMemoryTest`; fixed.
+- Re-run of `dependency:analyze -DskipTests` progressed and found module warnings before telegram test compile failure:
+  - `opendaimon-common`: no dependency problems at that point.
+  - `opendaimon-spring-ai`: unused declared warnings for:
+    - `org.springframework.ai:spring-ai-autoconfigure-model-chat-memory` runtime
+    - `org.springframework.ai:spring-ai-autoconfigure-model-chat-memory-repository-jdbc` runtime
+    - `com.h2database:h2` test
+  - `opendaimon-rest`: warnings:
+    - unused declared `org.hamcrest:hamcrest:test`
+    - non-test scoped test-only `com.fasterxml.jackson.core:jackson-core:compile`
+    - non-test scoped test-only `org.springframework:spring-beans:compile`
+  - `opendaimon-telegram`: test compile failed because handler tests still used old constructors; patched afterwards, but not re-run.
+- Targeted command `./mvnw -pl opendaimon-telegram -am test -DskipITs -DskipIT -DfailIfNoTests=false` failed in upstream `opendaimon-common` tests because `hibernate-validator` had been removed and Spring configuration properties validation needs a provider at test runtime.
+
+## Current blocker at interrupt
+`opendaimon-common` tests fail with:
+`jakarta.validation.NoProviderFoundException: Unable to create a Configuration, because no Jakarta Bean Validation provider could be found.`
+This came from `BulkHeadPropertiesTest` loading Spring context. Likely fix: add `org.hibernate.validator:hibernate-validator` back as test-scoped dependency in `opendaimon-common`, not compile scoped, unless production module needs to provide validation provider to downstream consumers. Verify analyzer afterwards.
+
+## Suggested module-by-module continuation plan
+1. `opendaimon-common`
+   - Add `hibernate-validator` as test dependency or otherwise provide validation provider only for tests.
+   - Run: `./mvnw -pl opendaimon-common test dependency:analyze -DskipITs -DskipIT`.
+   - Ensure no analyzer warnings.
+
+2. `opendaimon-spring-ai`
+   - Decide on analyzer handling for runtime Spring AI autoconfig glue and H2.
+   - If runtime autoconfig jars are intentionally present for Boot auto-configuration, add module-local `ignoredUnusedDeclaredDependencies` with precise comments.
+   - Remove H2 if genuinely unused, or ignore if Boot test infra loads it implicitly.
+   - Review `jakarta.persistence-api`: currently test scoped and compile has warnings about missing enum constants during app compile; may need compile scope if main bytecode references persistence types indirectly.
+   - Run: `./mvnw -pl opendaimon-spring-ai -am clean compile test dependency:analyze -DskipITs -DskipIT`.
+
+3. `opendaimon-rest`
+   - Remove `org.hamcrest:hamcrest` if no direct imports.
+   - For `spring-beans` and `jackson-core`, either move to test scope if truly test-only, or add `ignoredNonTestScopedDependencies` if they must remain main-runtime deps. Existing comment incorrectly only handles unused-declared category.
+   - Run: `./mvnw -pl opendaimon-rest -am clean compile test dependency:analyze -DskipITs -DskipIT`.
+
+4. `opendaimon-telegram`
+   - Re-run tests after patched constructors.
+   - Confirm Caffeine is declared directly because `TelegramChatPacerImpl` imports it.
+   - Run: `./mvnw -pl opendaimon-telegram -am clean compile test dependency:analyze -DskipITs -DskipIT`.
+
+5. `opendaimon-ui` and `opendaimon-gateway-mock`
+   - Run module analyzer/enforcer separately and fix only local warnings.
+
+6. `opendaimon-app` ArchUnit
+   - Run: `./mvnw -pl opendaimon-app -am test -Dtest=ArchitectureTest -Dsurefire.failIfNoSpecifiedTests=false`.
+   - Fix real violations, do not restore freeze store.
+
+7. Reactor final checks
+   - `./mvnw clean compile`
+   - `./mvnw dependency:analyze -DskipTests`
+   - targeted ArchUnit
+   - `./mvnw clean verify`
+
+## Notes for next session
+- Do not keep editing globally. Finish one module at a time and verify that module before moving on.
+- Watch Maven Enforcer merge behavior: module-local banned starter config may override root rules unless Maven merges as expected. Confirm with `clean verify`.
+- The banned starter pattern `org.springframework.boot:spring-boot-starter*` may need to be split into `spring-boot-starter` and `spring-boot-starter-*` if enforcer does not match as intended.
+- If Maven needs network and sandbox blocks it, rerun exact command with escalation per Codex instructions.
\ No newline at end of file
diff --git a/.serena/memories/workflow/subagent_usage_preference.md b/.serena/memories/workflow/subagent_usage_preference.md
new file mode 100644
index 00000000..bbe35c2e
--- /dev/null
+++ b/.serena/memories/workflow/subagent_usage_preference.md
@@ -0,0 +1,12 @@
+# Subagent Usage Preference
+
+User asked to use subagents autonomously only for larger work, especially when many modules are involved, to save main context.
+
+Apply this rule conservatively:
+- Do not spawn subagents for small, single-file, or straightforward tasks.
+- Consider subagents for large multi-module changes, broad investigations, parallel verification, or independent review tracks.
+- Keep delegated tasks concrete and bounded, with disjoint responsibilities where code edits are involved.
+- Continue to do the immediate blocking work locally; delegate only side work that can run in parallel.
+- Summarize subagent results back into the main thread instead of carrying all raw context forward.
+
+This preference does not override Codex/developer constraints: only use subagents when the user has authorized delegation/subagent use, and avoid unnecessary delegation.
\ No newline at end of file
diff --git a/.serena/project.yml b/.serena/project.yml
index 99b3bd60..7d9c2a11 100644
--- a/.serena/project.yml
+++ b/.serena/project.yml
@@ -3,15 +3,18 @@ project_name: "open-daimon"
 
 
 # list of languages for which language servers are started; choose from:
-#   al                  bash                clojure             cpp                 csharp
-#   csharp_omnisharp    dart                elixir              elm                 erlang
-#   fortran             fsharp              go                  groovy              haskell
-#   java                julia               kotlin              lua                 markdown
-#   matlab              nix                 pascal              perl                php
-#   php_phpactor        powershell          python              python_jedi         r
-#   rego                ruby                ruby_solargraph     rust                scala
-#   swift               terraform           toml                typescript          typescript_vts
-#   vue                 yaml                zig
+#   al                  ansible             bash                clojure             cpp
+#   cpp_ccls            crystal             csharp              csharp_omnisharp    dart
+#   elixir              elm                 erlang              fortran             fsharp
+#   go                  groovy              haskell             haxe                hlsl
+#   java                json                julia               kotlin              lean4
+#   lua                 luau                markdown            matlab              msl
+#   nix                 ocaml               pascal              perl                php
+#   php_phpactor        powershell          python              python_jedi         python_ty
+#   r                   rego                ruby                ruby_solargraph     rust
+#   scala               solidity            swift               systemverilog       terraform
+#   toml                typescript          typescript_vts      vue                 yaml
+#   zig
 #   (This list may be outdated. For the current list, see values of Language enum here:
 #   https://github.com/oraios/serena/blob/main/src/solidlsp/ls_config.py
 #   For some languages, there are alternative language servers, e.g. csharp_omnisharp, ruby_solargraph.)
@@ -65,53 +68,17 @@ read_only: false
 
 # list of tool names to exclude.
 # This extends the existing exclusions (e.g. from the global configuration)
-#
-# Below is the complete list of tools for convenience.
-# To make sure you have the latest list of tools, and to view their descriptions, 
-# execute `uv run scripts/print_tool_overview.py`.
-#
-#  * `activate_project`: Activates a project by name.
-#  * `check_onboarding_performed`: Checks whether project onboarding was already performed.
-#  * `create_text_file`: Creates/overwrites a file in the project directory.
-#  * `delete_lines`: Deletes a range of lines within a file.
-#  * `delete_memory`: Deletes a memory from Serena's project-specific memory store.
-#  * `execute_shell_command`: Executes a shell command.
-#  * `find_referencing_code_snippets`: Finds code snippets in which the symbol at the given location is referenced.
-#  * `find_referencing_symbols`: Finds symbols that reference the symbol at the given location (optionally filtered by type).
-#  * `find_symbol`: Performs a global (or local) search for symbols with/containing a given name/substring (optionally filtered by type).
-#  * `get_current_config`: Prints the current configuration of the agent, including the active and available projects, tools, contexts, and modes.
-#  * `get_symbols_overview`: Gets an overview of the top-level symbols defined in a given file.
-#  * `initial_instructions`: Gets the initial instructions for the current project.
-#     Should only be used in settings where the system prompt cannot be set,
-#     e.g. in clients you have no control over, like Claude Desktop.
-#  * `insert_after_symbol`: Inserts content after the end of the definition of a given symbol.
-#  * `insert_at_line`: Inserts content at a given line in a file.
-#  * `insert_before_symbol`: Inserts content before the beginning of the definition of a given symbol.
-#  * `list_dir`: Lists files and directories in the given directory (optionally with recursion).
-#  * `list_memories`: Lists memories in Serena's project-specific memory store.
-#  * `onboarding`: Performs onboarding (identifying the project structure and essential tasks, e.g. for testing or building).
-#  * `prepare_for_new_conversation`: Provides instructions for preparing for a new conversation (in order to continue with the necessary context).
-#  * `read_file`: Reads a file within the project directory.
-#  * `read_memory`: Reads the memory with the given name from Serena's project-specific memory store.
-#  * `remove_project`: Removes a project from the Serena configuration.
-#  * `replace_lines`: Replaces a range of lines within a file with new content.
-#  * `replace_symbol_body`: Replaces the full definition of a symbol.
-#  * `restart_language_server`: Restarts the language server, may be necessary when edits not through Serena happen.
-#  * `search_for_pattern`: Performs a search for a pattern in the project.
-#  * `summarize_changes`: Provides instructions for summarizing the changes made to the codebase.
-#  * `switch_modes`: Activates modes by providing a list of their names
-#  * `think_about_collected_information`: Thinking tool for pondering the completeness of collected information.
-#  * `think_about_task_adherence`: Thinking tool for determining whether the agent is still on track with the current task.
-#  * `think_about_whether_you_are_done`: Thinking tool for determining whether the task is truly completed.
-#  * `write_memory`: Writes a named memory (for future reference) to Serena's project-specific memory store.
+# Find the list of tools here: https://oraios.github.io/serena/01-about/035_tools.html
 excluded_tools: []
 
 # list of tools to include that would otherwise be disabled (particularly optional tools that are disabled by default).
 # This extends the existing inclusions (e.g. from the global configuration).
+# Find the list of tools here: https://oraios.github.io/serena/01-about/035_tools.html
 included_optional_tools: []
 
 # fixed set of tools to use as the base tool set (if non-empty), replacing Serena's default set of tools.
 # This cannot be combined with non-empty excluded_tools or included_optional_tools.
+# Find the list of tools here: https://oraios.github.io/serena/01-about/035_tools.html
 fixed_tools: []
 
 # list of mode names to that are always to be included in the set of active modes
@@ -122,11 +89,14 @@ fixed_tools: []
 # Set this to a list of mode names to always include the respective modes for this project.
 base_modes:
 
-# list of mode names that are to be activated by default.
-# The full set of modes to be activated is base_modes + default_modes.
-# If the setting is undefined, the default_modes from the global configuration (serena_config.yml) apply.
+# list of mode names that are to be activated by default, overriding the setting in the global configuration.
+# The full set of modes to be activated is base_modes (from global config) + default_modes + added_modes.
+# If the setting is undefined/empty, the default_modes from the global configuration (serena_config.yml) apply.
 # Otherwise, this overrides the setting from the global configuration (serena_config.yml).
+# Therefore, you can set this to [] if you do not want the default modes defined in the global config to apply
+# for this project.
 # This setting can, in turn, be overridden by CLI parameters (--mode).
+# See https://oraios.github.io/serena/02-usage/050_configuration.html#modes
 default_modes:
 
 # initial prompt for the project. It will always be given to the LLM upon activating the project
@@ -150,3 +120,8 @@ read_only_memory_patterns: []
 # Extends the list from the global configuration, merging the two lists.
 # Example: ["_archive/.*", "_episodes/.*"]
 ignored_memory_patterns: []
+
+# list of mode names to be activated additionally for this project, e.g. ["query-projects"]
+# The full set of modes to be activated is base_modes (from global config) + default_modes + added_modes.
+# See https://oraios.github.io/serena/02-usage/050_configuration.html#modes
+added_modes:
diff --git a/AGENTS.md b/AGENTS.md
index 00d61be6..00a321cb 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -21,18 +21,37 @@ Consequences for any change touching `pom.xml`, public types, or shared APIs:
 
 ## Rules for AI Agents
 
-### Serena activation on session start
+### Codex subagents
 
-- At the beginning of each new session in this repository, verify Serena state first.
-- If Serena reports `Active Project: None`, immediately call `activate_project("open-daimon")`.
-- Do this before any code exploration or edits to ensure project-aware symbol tooling works correctly.
+- Use Codex subagents only when the user explicitly asks for delegation, parallel agent work, or a subagent.
+- For small, bounded side tasks, prefer a Spark-backed Codex subagent with `model: gpt-5.3-codex-spark` and the lightest reasoning effort that fits the task.
+- Keep Spark subagent work concrete and sidecar: codebase lookup, narrow verification, or a small disjoint patch. Do not hand off the immediate blocking task if the main agent needs that result before moving.
+- When assigning a worker subagent, define its owned files or module clearly, and tell it that other changes may exist in the same worktree and must not be reverted.
+
+### Serena project context
+
+- Before using Serena tools for project-aware navigation, silently verify that the active project is `open-daimon`.
+- If Serena is inactive or points to another project, activate `open-daimon`.
+- Do not mention this check in user-facing updates unless activation fails or the Serena state is directly relevant to the task.
 
 ### MCP tools for information lookup
 
-- Two MCP servers are available and should be used for information lookup when relevant:
+- MCP servers are available and should be used for information lookup when relevant:
   - `Serena` — codebase navigation, symbol search, and project-aware exploration.
+  - `JetBrains` — IDE-indexed code search/navigation, symbol documentation, rename refactoring, open-editor context, and inspections.
   - `Context7` — library/framework documentation lookup and API usage search.
 - Prefer these MCP tools first for discovery and verification before broader ad-hoc searching.
+- Prefer JetBrains MCP for Java refactoring and IDE-backed checks: use it before text-only replacement for renames, before broad shell search when IDE indexing is likely more precise, and for targeted file diagnostics after edits.
+- Prefer Context7 for Spring AI, OpenAI API, MCP SDK/transport, Maven plugin, and dependency API questions before answering or implementing from memory.
+
+### Code exploration with ast-outline
+
+- Use `ast-outline` as a pre-read layer for supported source and documentation files when a structural view is enough.
+- For unfamiliar directories, start with `ast-outline digest <paths...>` to get a compact type and public-method map.
+- For file-level shape, use `ast-outline <paths...>` to inspect declarations with line ranges and without method bodies.
+- For one method, type, markdown heading, or YAML key, use `ast-outline show <file> <Symbol>` and then read the full file only if the extracted context is not enough.
+- For implementation lookups, use `ast-outline implements <Type> <paths...>` when an AST-based search is more precise than text search.
+- Batch paths in one call where useful. `ast-outline` complements `rg`, Serena, and JetBrains; it does not replace IDE-backed symbol navigation or full reads when exact code context is needed.
 
 ### Documentation maintenance
 
@@ -40,6 +59,12 @@ Consequences for any change touching `pom.xml`, public types, or shared APIs:
 - If you add or change a use case, command flow, branching condition, input/output format, or error path — update the corresponding doc in the same commit.
 - Docs live next to the module root (e.g. `opendaimon-spring-ai/SPRING_AI_MODULE.md`, `opendaimon-telegram/TELEGRAM_MODULE.md`).
 
+### ArchUnit scope
+
+- Keep ArchUnit focused on modules with meaningful architectural boundaries: `opendaimon-common`, `opendaimon-spring-ai`, `opendaimon-telegram`, `opendaimon-rest`, and cross-module checks from `opendaimon-app`.
+- Do not add module-local ArchUnit suites to `opendaimon-ui` or `opendaimon-gateway-mock` while they remain thin support modules without their own repository/domain/service layering.
+- For `opendaimon-ui` and `opendaimon-gateway-mock`, prefer compile checks, dependency analysis/enforcer checks, and focused behavior tests when behavior changes. Reconsider ArchUnit only if one of these modules grows stable internal architectural boundaries that need executable enforcement.
+
 ### Language in code and documentation
 
 - **Code, comments, javadoc, commit messages, and in-repo documentation** must be written in **English**.
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 309deec7..78dce6a0 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -75,6 +75,16 @@ Before submitting a Pull Request, ensure:
 4. JavaDoc is added or updated for public APIs where relevant.
 5. No secrets or API keys are committed (use environment variables or `.env`).
 
+## Contribution licensing
+
+By submitting a contribution, you certify that you have the right to submit it
+and agree to license it under the Apache License, Version 2.0.
+
+You also grant Nikolai Girchev a perpetual, worldwide, non-exclusive,
+royalty-free right to use, reproduce, modify, distribute, sublicense, and
+relicense your contribution as part of OpenDaimon and related commercial or
+closed-source products.
+
 ## Security
 
 - **API keys and secrets**: Only in environment variables or `.env` (and `.env` must not be committed).
diff --git a/Dockerfile b/Dockerfile
index 4cdea25c..baf1a4ae 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -8,6 +8,7 @@ ARG APP_VERSION=1.0.0-SNAPSHOT
 COPY pom.xml .
 COPY opendaimon-common/pom.xml ./opendaimon-common/
 COPY opendaimon-spring-ai/pom.xml ./opendaimon-spring-ai/
+COPY opendaimon-spring-boot-starter/pom.xml ./opendaimon-spring-boot-starter/
 COPY opendaimon-ui/pom.xml ./opendaimon-ui/
 COPY opendaimon-rest/pom.xml ./opendaimon-rest/
 COPY opendaimon-telegram/pom.xml ./opendaimon-telegram/
@@ -43,4 +44,3 @@ EXPOSE 8080
 
 # Run application
 ENTRYPOINT ["java", "-jar", "app.jar"]
-
diff --git a/LICENSE b/LICENSE
index c686a91d..66af111c 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,21 +1,182 @@
-MIT License
-
-Copyright (c) 2026 Nikolai Girchev
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, "control" means (i) the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+"Object" form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form,
+made available under the License, as indicated by a copyright notice that is
+included in or attached to the work (an example is provided in the Appendix
+below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative Works
+thereof, that is intentionally submitted to Licensor for inclusion in the Work by
+the copyright owner or by an individual or Legal Entity authorized to submit on
+behalf of the copyright owner. For the purposes of this definition, "submitted"
+means any form of electronic, verbal, or written communication sent to the
+Licensor or its representatives, including but not limited to communication on
+electronic mailing lists, source code control systems, and issue tracking systems
+that are managed by, or on behalf of, the Licensor for the purpose of discussing
+and improving the Work, but excluding communication that is conspicuously marked
+or otherwise designated in writing by the copyright owner as "Not a
+Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this
+License, each Contributor hereby grants to You a perpetual, worldwide,
+non-exclusive, no-charge, royalty-free, irrevocable copyright license to
+reproduce, prepare Derivative Works of, publicly display, publicly perform,
+sublicense, and distribute the Work and such Derivative Works in Source or
+Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this License,
+each Contributor hereby grants to You a perpetual, worldwide, non-exclusive,
+no-charge, royalty-free, irrevocable (except as stated in this section) patent
+license to make, have made, use, offer to sell, sell, import, and otherwise
+transfer the Work, where such license applies only to those patent claims
+licensable by such Contributor that are necessarily infringed by their
+Contribution(s) alone or by combination of their Contribution(s) with the Work to
+which such Contribution(s) was submitted. If You institute patent litigation
+against any entity (including a cross-claim or counterclaim in a lawsuit)
+alleging that the Work or a Contribution incorporated within the Work constitutes
+direct or contributory patent infringement, then any patent licenses granted to
+You under this License for that Work shall terminate as of the date such
+litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or
+Derivative Works thereof in any medium, with or without modifications, and in
+Source or Object form, provided that You meet the following conditions:
+
+(a) You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+
+(b) You must cause any modified files to carry prominent notices stating that You
+changed the files; and
+
+(c) You must retain, in the Source form of any Derivative Works that You
+distribute, all copyright, patent, trademark, and attribution notices from the
+Source form of the Work, excluding those notices that do not pertain to any part
+of the Derivative Works; and
+
+(d) If the Work includes a "NOTICE" text file as part of its distribution, then
+any Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of the
+following places: within a NOTICE text file distributed as part of the Derivative
+Works; within the Source form or documentation, if provided along with the
+Derivative Works; or, within a display generated by the Derivative Works, if and
+wherever such third-party notices normally appear. The contents of the NOTICE
+file are for informational purposes only and do not modify the License. You may
+add Your own attribution notices within Derivative Works that You distribute,
+alongside or as an addendum to the NOTICE text from the Work, provided that such
+additional attribution notices cannot be construed as modifying the License.
+
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a whole,
+provided Your use, reproduction, and distribution of the Work otherwise complies
+with the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any
+Contribution intentionally submitted for inclusion in the Work by You to the
+Licensor shall be under the terms and conditions of this License, without any
+additional terms or conditions. Notwithstanding the above, nothing herein shall
+supersede or modify the terms of any separate license agreement you may have
+executed with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade names,
+trademarks, service marks, or product names of the Licensor, except as required
+for reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in
+writing, Licensor provides the Work (and each Contributor provides its
+Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+either express or implied, including, without limitation, any warranties or
+conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+PARTICULAR PURPOSE. You are solely responsible for determining the
+appropriateness of using or redistributing the Work and assume any risks
+associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in
+tort (including negligence), contract, or otherwise, unless required by
+applicable law (such as deliberate and grossly negligent acts) or agreed to in
+writing, shall any Contributor be liable to You for damages, including any
+direct, indirect, special, incidental, or consequential damages of any character
+arising as a result of this License or out of the use or inability to use the
+Work (including but not limited to damages for loss of goodwill, work stoppage,
+computer failure or malfunction, or any and all other commercial damages or
+losses), even if such Contributor has been advised of the possibility of such
+damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or
+Derivative Works thereof, You may choose to offer, and charge a fee for,
+acceptance of support, warranty, indemnity, or other liability obligations and/or
+rights consistent with this License. However, in accepting such obligations, You
+may act only on Your own behalf and on Your sole responsibility, not on behalf of
+any other Contributor, and only if You agree to indemnify, defend, and hold each
+Contributor harmless for any liability incurred by, or claims asserted against,
+such Contributor by reason of your accepting any such warranty or additional
+liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+To apply the Apache License to your work, attach the following boilerplate
+notice, with the fields enclosed by brackets "[]" replaced with your own
+identifying information. (Do not include the brackets!) The text should be
+enclosed in the appropriate comment syntax for the file format. We also
+recommend that a file or class name and description of purpose be included on the
+same "printed page" as the copyright notice for easier identification within
+third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
diff --git a/NOTICE b/NOTICE
new file mode 100644
index 00000000..131397f6
--- /dev/null
+++ b/NOTICE
@@ -0,0 +1,6 @@
+OpenDaimon
+Copyright 2026 Nikolai Girchev
+
+This product includes software developed by Nikolai Girchev.
+
+OpenDaimon is distributed under the Apache License, Version 2.0.
diff --git a/README.md b/README.md
index 1bb61864..2e1d4f74 100644
--- a/README.md
+++ b/README.md
@@ -22,7 +22,9 @@
 
 [![Java 21](https://img.shields.io/badge/Java-21-ED8B00?logo=openjdk)](https://openjdk.org/)
 [![Spring Boot 3.3.3](https://img.shields.io/badge/Spring%20Boot-3.3.3-6DB33F?logo=springboot)](https://spring.io/projects/spring-boot)
-[![License](https://img.shields.io/github/license/NGirchev/open-daimon)](https://github.com/NGirchev/open-daimon/blob/master/LICENSE)
+[![License: Apache-2.0](https://img.shields.io/badge/license-Apache--2.0-blue)](https://github.com/NGirchev/open-daimon/blob/master/LICENSE)
+
+![Screen Recording 2026-05-03 at 23.28.03.gif](Screen%20Recording%202026-05-03%20at%2023.28.03.gif)
 
 ## Quick Setup
 
@@ -711,6 +713,7 @@ File -> Invalidate Caches / Restart
 
 - **[docs/setup-telegram.md](docs/setup-telegram.md)** — Create a Telegram bot and get your user ID
 - **[docs/setup-serper.md](docs/setup-serper.md)** — Enable web search (optional)
+- **[docs/codex/setup.md](docs/codex/setup.md)** — Recreate the Codex, MCP, and Serena workstation setup
 
 ### Project docs
 
@@ -762,4 +765,10 @@ docker-compose -H tcp://localhost:23750 up -d
 
 ## License
 
-See [LICENSE](LICENSE) file for details.
+OpenDaimon is licensed under the Apache License, Version 2.0. See
+[LICENSE](LICENSE) and [NOTICE](NOTICE) for details.
+
+The Apache License does not grant trademark rights. If you distribute a fork,
+modified version, hosted service, or commercial product based on OpenDaimon, use
+a distinct product name and preserve the required attribution notices. See
+[TRADEMARKS.md](TRADEMARKS.md).
diff --git a/Screen Recording 2026-05-03 at 23.28.03.gif b/Screen Recording 2026-05-03 at 23.28.03.gif
new file mode 100644
index 00000000..47fb8a5f
Binary files /dev/null and b/Screen Recording 2026-05-03 at 23.28.03.gif differ
diff --git a/TODO.md b/TODO.md
index 1d00d386..b710face 100644
--- a/TODO.md
+++ b/TODO.md
@@ -46,14 +46,79 @@
 - [ ] Provider Registry — replace ProviderType enum with String + Strategy pattern ([plan](docs/provider-registry-plan.md))
 - [ ] Different models in the flow
 - [ ] Add balance loader
+- [ ] Do not show the embedding models (add hide param for models to application.yml)
 - [x] WebTools need to parse result — JSoup-based HTML parsing in `WebTools.java:5,173` strips markup and returns clean text to the model
-- [ ] **opendaimon-spring-boot-starter** — auto-configuration starter for easy integration 
-  - [ ] New module `opendaimon-spring-boot-starter` with `AutoConfiguration.imports`
-  - [ ] Minimal dependency: `opendaimon-common` + `opendaimon-spring-ai`
-  - [ ] **Module hygiene & ArchUnit** — enforce clean module boundaries before publishing to Maven Central (see `AGENTS.md` § Project Nature)
-  - [ ] **`./mvnw dependency:analyze` reactor-wide** — fix every `Used undeclared dependencies` and `Unused declared dependencies` finding, then wire `maven-dependency-plugin:analyze-only` into the `verify` phase with `failOnWarning=true` so future undeclared / unused deps break CI. First known cases: `opendaimon-telegram` uses Caffeine in `TelegramChatPacerImpl` without declaring it (transitively via `opendaimon-common`); `opendaimon-spring-ai` re-declares Caffeine that already comes through `opendaimon-common` — keep the declaration (per "declare what you use") and verify nothing else falls in the same trap.
-  - [ ] **ArchUnit test module** — inter-module boundary rules (`opendaimon-telegram` ↛ `opendaimon-rest`, `opendaimon-rest` ↛ `opendaimon-telegram`, only `opendaimon-app` may depend on multiple delivery-channel modules), per-module layering (`config` → `service` → `repository`, never the reverse), and a "no `@Service`/`@Component`/`@Repository` outside test sources" guard that codifies the explicit-`@Bean` rule from `AGENTS.md` § Spring Bean Configuration.
-  - [ ] **`maven-enforcer-plugin` rules** — `dependencyConvergence` (single resolved version per transitive dep), `requireUpperBoundDeps`, `bannedDependencies` (no `commons-logging`, no `*-spring-boot-starter` in non-`opendaimon-app` modules to keep delivery-channel modules embeddable in third-party Spring Boot apps).
+- [x] **opendaimon-spring-boot-starter** — auto-configuration starter for easy integration
+  - [x] New module `opendaimon-spring-boot-starter` with `AutoConfiguration.imports`
+  - [x] Minimal dependency: `opendaimon-common` + `opendaimon-spring-ai`
+  - [x] Standalone consumer example outside the published reactor (`starter-consumer-example`)
+  - [x] Consumer example with REST API, Spring AI, dotenv loading, and opt-in OpenRouter contract test
+  - [x] **Module hygiene & ArchUnit** — enforce clean module boundaries before publishing to Maven Central (see `AGENTS.md` § Project Nature)
+  - [x] **`./mvnw dependency:analyze` reactor-wide** — fix every `Used undeclared dependencies` and `Unused declared dependencies` finding, then wire `maven-dependency-plugin:analyze-only` into the `verify` phase with `failOnWarning=true` so future undeclared / unused deps break CI. First known cases: `opendaimon-telegram` uses Caffeine in `TelegramChatPacerImpl` without declaring it (transitively via `opendaimon-common`); `opendaimon-spring-ai` re-declares Caffeine that already comes through `opendaimon-common` — keep the declaration (per "declare what you use") and verify nothing else falls in the same trap.
+  - [x] **ArchUnit test module** — inter-module boundary rules (`opendaimon-telegram` ↛ `opendaimon-rest`, `opendaimon-rest` ↛ `opendaimon-telegram`, only `opendaimon-app` may depend on multiple delivery-channel modules), per-module layering (`config` → `service` → `repository`, never the reverse), and a guard that forbids `@Service` / `@Component` beans plus concrete `@Repository` classes outside test sources while allowing Spring Data repository interfaces.
+  - [x] **`maven-enforcer-plugin` rules** — `dependencyConvergence` (single resolved version per transitive dep), `requireUpperBoundDeps`, `bannedDependencies` (no `commons-logging`, no `*-spring-boot-starter` in non-`opendaimon-app` modules to keep delivery-channel modules embeddable in third-party Spring Boot apps).
+  - [x] **Continuation checkpoint: module hygiene / dependency analyze / ArchUnit**
+    - [x] Root Maven hygiene baseline
+      - Spring Boot aligned to `3.5.13`.
+      - Removed explicit Spring Framework BOM override.
+      - Added `maven-dependency-plugin:analyze-only` in `verify` with `failOnWarning=true`.
+      - Added root `maven-enforcer-plugin` in `verify` with `dependencyConvergence`, `requireUpperBoundDeps`, and transitive `commons-logging:commons-logging` ban.
+      - Added managed `archunit.version=1.4.2` and `maven-enforcer-plugin.version=3.6.2`.
+    - [x] Non-app starter ban baseline
+      - Added module-local enforcer config banning transitive `org.springframework.boot:spring-boot-starter*` in `opendaimon-common`, `opendaimon-spring-ai`, `opendaimon-rest`, `opendaimon-telegram`, `opendaimon-ui`, and `opendaimon-gateway-mock`.
+      - Follow-up verification still needed: confirm the module-local enforcer config merges with root convergence / upper-bound / commons-logging rules instead of overriding them.
+    - [x] ArchUnit baseline
+      - Added `opendaimon-app/src/test/java/io/github/ngirchev/opendaimon/arch/ArchitectureTest.java`.
+      - Rules cover no `@Service` / `@Component` beans and no concrete `@Repository` classes in main module packages, no library-module cycles, telegram ↛ rest, rest ↛ telegram, only app/root may depend on multiple delivery channels, and repository access only from `service` / `config`.
+      - Removed frozen ArchUnit store/config files; do not restore freeze mode.
+    - [x] `opendaimon-common` ArchUnit hardening
+      - Added `opendaimon-common/src/test/java/io/github/ngirchev/opendaimon/common/arch/CommonArchitectureTest.java`.
+      - Rules cover no `@Service` / `@Component` beans, no concrete `@Repository` classes, no delivery controllers in common/bulkhead, no downstream module dependencies, no common runtime slice cycles, repository interfaces, repository access boundaries, and config/property package conventions.
+      - Verified with `./mvnw clean compile -pl opendaimon-common`, `./mvnw test -pl opendaimon-common -Dtest=CommonArchitectureTest`, and `./mvnw test -pl opendaimon-common` (283 tests, 0 failures/errors, 2 skipped).
+    - [x] Repository boundary cleanup in production code
+      - `ConversationThreadService` gained `findThreads(...)`, `closeCurrentThread(...)`, and read-only `findByThreadKey(...)`.
+      - `OpenDaimonMessageService` gained read methods used by Telegram and Spring AI memory code.
+      - `HistoryTelegramCommandHandler`, `ThreadsTelegramCommandHandler`, `NewThreadTelegramCommandHandler`, and `SummarizingChatMemory` were moved off direct repository access.
+      - `TelegramCommandHandlerConfig` and `SpringAIAutoConfig` constructor wiring was updated for the service-layer boundary.
+    - [x] Tests updated so far
+      - `SummarizingChatMemoryTest` uses service mocks instead of repository mocks.
+      - `HistoryTelegramCommandHandlerTest`, `ThreadsTelegramCommandHandlerTest`, and `NewThreadTelegramCommandHandlerTest` were patched for the new constructors/service methods, but still need a clean re-run.
+    - [x] `opendaimon-common` module cleanup
+      - `org.hibernate.validator:hibernate-validator` is declared as a test-scoped validation provider for `BulkHeadPropertiesTest`; it is not exported as compile API.
+      - ArchUnit test dependencies are declared as direct test dependencies (`archunit`, `archunit-junit5-api`) plus the JUnit Platform runtime engine (`archunit-junit5-engine`) with a targeted analyzer ignore.
+      - Verified with `./mvnw -pl opendaimon-common test dependency:analyze -DskipITs -DskipIT`: 283 tests, 0 failures/errors, 2 skipped; dependency analyzer reports `No dependency problems found`.
+    - [x] `opendaimon-spring-ai` module cleanup
+      - Resolved previous analyzer warnings for Spring AI chat-memory autoconfig runtime glue and `com.h2database:h2:test`.
+      - Kept module-local ArchUnit dependencies with a targeted analyzer ignore for the JUnit Platform runtime engine.
+      - Verified with `./mvnw -pl opendaimon-spring-ai -am clean compile dependency:analyze -DskipTests -DskipITs -DskipIT`: dependency analyzer reports `No dependency problems found`.
+      - Verified module tests with `./mvnw -pl opendaimon-spring-ai -am test -Dtest='io.github.ngirchev.opendaimon.ai.springai.**.*Test' -Dsurefire.failIfNoSpecifiedTests=false -DskipITs -DskipIT`: 463 tests, 0 failures/errors, 1 skipped.
+    - [x] `opendaimon-rest` module cleanup
+      - Added REST-local `RestArchitectureTest` with layer, explicit-configuration, repository, DTO/model, and service/delivery boundary rules.
+      - Added REST ArchUnit test dependencies and targeted analyzer ignore for the JUnit Platform engine.
+      - Kept `org.hamcrest:hamcrest:test` because `SessionControllerContractTest` imports Hamcrest matchers directly.
+      - Resolved previous `jackson-core` / `spring-beans` analyzer warnings through direct dependency cleanup.
+      - Verified with `./mvnw -pl opendaimon-rest -am clean compile -DskipTests`, `./mvnw -pl opendaimon-rest -am test -Dtest=RestArchitectureTest -Dsurefire.failIfNoSpecifiedTests=false -DskipITs -DskipIT`, `./mvnw -pl opendaimon-rest -am dependency:analyze -DskipTests`, and `./mvnw -pl opendaimon-rest -am test -DskipITs -DskipIT`.
+    - [x] `opendaimon-telegram` module cleanup
+      - Re-ran tests after handler-test constructor patches.
+      - Confirmed `com.github.ben-manes.caffeine:caffeine` is declared directly because `TelegramChatPacerImpl` imports it.
+      - Verified with `./mvnw -pl opendaimon-telegram -am clean compile dependency:analyze -DskipTests -DskipITs -DskipIT`: dependency analyzer reports `No dependency problems found`.
+      - Verified module tests with `./mvnw -pl opendaimon-telegram -am clean test -Dtest='io.github.ngirchev.opendaimon.telegram.**.*Test' -Dsurefire.failIfNoSpecifiedTests=false -DskipITs -DskipIT`: 481 tests, 0 failures/errors, 19 skipped.
+    - [x] `opendaimon-ui` and `opendaimon-gateway-mock` module cleanup
+      - Run analyzer/enforcer per module and fix only local POM warnings.
+    - [x] `opendaimon-app` ArchUnit verification
+      - Run `./mvnw -pl opendaimon-app -am test -Dtest=ArchitectureTest -Dsurefire.failIfNoSpecifiedTests=false`.
+      - Fix real boundary/layer violations in code; do not reintroduce frozen ArchUnit rules.
+      - Verified with `./mvnw -pl opendaimon-app -am test -Dtest=ArchitectureTest -Dsurefire.failIfNoSpecifiedTests=false`: `ArchitectureTest` passed (7 tests, 0 failures/errors/skipped).
+    - [x] Final reactor verification
+      - Run `./mvnw clean compile`.
+      - Run `./mvnw dependency:analyze -DskipTests`.
+      - Run targeted `ArchitectureTest`.
+      - Run `./mvnw clean verify`.
+      - Verified `./mvnw clean compile`: reactor build success across 8 modules.
+      - Verified `./mvnw dependency:analyze -DskipTests`: dependency analyzer reports `No dependency problems found` across all jar modules.
+      - Verified `./mvnw -pl opendaimon-app -am test -Dtest=ArchitectureTest -Dsurefire.failIfNoSpecifiedTests=false`: `ArchitectureTest` passed (7 tests, 0 failures/errors/skipped).
+      - First sandboxed `./mvnw clean verify` failed in `opendaimon-spring-ai` because the sandbox blocked local socket binding / DNS used by tests (`MockWebServer.start`, `example.com`).
+      - Verified outside the sandbox with `./mvnw clean verify`: full reactor build success; `dependency:analyze-only` and enforcer rules passed in `verify`, including app integration tests.
 
 ## Agent Framework Pivot
 
diff --git a/TRADEMARKS.md b/TRADEMARKS.md
new file mode 100644
index 00000000..b4e056c8
--- /dev/null
+++ b/TRADEMARKS.md
@@ -0,0 +1,18 @@
+# Trademarks
+
+The Apache License, Version 2.0 grants rights to use, copy, modify, and
+redistribute the OpenDaimon software. It does not grant trademark rights.
+
+The names "OpenDaimon" and "OpenDaimon AI", the project logos, and associated
+branding are trademarks or project identifiers of Nikolai Girchev.
+
+You may use the OpenDaimon name to truthfully refer to the original project,
+compatible integrations, or unmodified distributions.
+
+You may not use the OpenDaimon name, logos, or branding in a way that suggests
+that a modified version, hosted service, commercial product, or third-party
+distribution is the official OpenDaimon project or is endorsed by Nikolai Girchev
+without written permission.
+
+If you distribute a fork or modified version, use a distinct product name and
+clearly state that it is derived from OpenDaimon.
diff --git a/cli/TESTING.md b/cli/TESTING.md
index 9fce9a29..1c120bd3 100644
--- a/cli/TESTING.md
+++ b/cli/TESTING.md
@@ -36,17 +36,23 @@ This is the closest simulation to what an end-user runs. It verifies:
 
 Pass `--local-image` to the wizard — it generates `docker-compose.yml` with `open-daimon:local` and `pull_policy: never` instead of pulling from the internet.
 
-**Step 1** — build the local image from the repository root:
+**Step 1** — build the local image from the repository root or from the repository `cli/` directory:
 
 ```bash
-cd ..
-docker build -t open-daimon:local .
+OPEN_DAIMON_REPO="$(git -C . rev-parse --show-toplevel)"
+docker build -t open-daimon:local "$OPEN_DAIMON_REPO"
+```
+
+Verify that Docker can see the image before running the wizard:
+
+```bash
+docker image inspect open-daimon:local >/dev/null
 ```
 
 **Step 2** — pack the wizard:
 
 ```bash
-cd cli
+cd "$OPEN_DAIMON_REPO/cli"
 npm pack --pack-destination /tmp/
 ```
 
@@ -57,6 +63,10 @@ cd /tmp/test-pack
 npx file:/tmp/ngirchev-open-daimon-1.0.1.tgz --local-image
 ```
 
+If you choose `Start the stack now?`, the wizard checks that `open-daimon:local` exists before `docker compose up -d`.
+If the image is missing, it stops with the build command instead of partially creating containers and failing with
+`No such image: open-daimon:local`.
+
 ---
 
 ## Setup (once)
diff --git a/cli/bin/setup.js b/cli/bin/setup.js
index d300926f..09d067da 100644
--- a/cli/bin/setup.js
+++ b/cli/bin/setup.js
@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { input, password, select, checkbox, confirm } from '@inquirer/prompts';
-import { execSync, spawn } from 'child_process';
+import { execFileSync, execSync, spawn } from 'child_process';
 import { existsSync, readFileSync, writeFileSync, rmSync, statSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
@@ -24,6 +24,15 @@ function checkCommand(cmd) {
   }
 }
 
+function dockerImageExists(image) {
+  try {
+    execFileSync('docker', ['image', 'inspect', image], { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 async function checkOllama(url) {
   try {
     const res = await fetch(url, { signal: AbortSignal.timeout(3000) });
@@ -49,9 +58,17 @@ function spawnAsync(cmd, args, cwd) {
   return new Promise((resolve) => {
     const proc = spawn(cmd, args, { stdio: 'inherit', cwd });
     proc.on('close', resolve);
+    proc.on('error', () => resolve(1));
   });
 }
 
+async function runCommand(cmd, args, cwd) {
+  const code = await spawnAsync(cmd, args, cwd);
+  if (code !== 0) {
+    throw new Error(`Command failed: ${[cmd, ...args].join(' ')}`);
+  }
+}
+
 async function waitForApp(url, timeoutMs = 120000) {
   const start = Date.now();
   process.stdout.write('\nWaiting for app to be ready');
@@ -393,14 +410,28 @@ async function main() {
     default: true,
   });
   if (doStart) {
-    console.log('\nDownloading images (this may take a few minutes on first run)...');
-    await spawnAsync(composeCmd[0], [...composeCmd.slice(1), 'pull'], TARGET_DIR);
+    if (USE_LOCAL_IMAGE) {
+      if (!dockerImageExists(APP_IMAGE)) {
+        console.error(`\nLocal Docker image ${APP_IMAGE} was not found.`);
+        console.error('Build it from the open-daimon repository root first.');
+        console.error('If you are in the repository cli/ directory, run:');
+        console.error('  OPEN_DAIMON_REPO="$(cd .. && pwd)"');
+        console.error(`  docker build -t ${APP_IMAGE} "$OPEN_DAIMON_REPO"`);
+        console.error('\nThen start the generated stack from this directory:');
+        console.error('  docker compose up -d');
+        process.exit(1);
+      }
+      console.log(`\nUsing local Docker image ${APP_IMAGE}.`);
+    } else {
+      console.log('\nDownloading images (this may take a few minutes on first run)...');
+      await runCommand(composeCmd[0], [...composeCmd.slice(1), 'pull'], TARGET_DIR);
+    }
 
     console.log('\nStarting containers...');
-    await spawnAsync(composeCmd[0], [...composeCmd.slice(1), 'up', '-d'], TARGET_DIR);
+    await runCommand(composeCmd[0], [...composeCmd.slice(1), 'up', '-d'], TARGET_DIR);
 
     console.log('\nContainer status:');
-    await spawnAsync(composeCmd[0], [...composeCmd.slice(1), 'ps'], TARGET_DIR);
+    await runCommand(composeCmd[0], [...composeCmd.slice(1), 'ps'], TARGET_DIR);
 
     await waitForApp('http://localhost:8080/actuator/health');
   }
diff --git a/cli/package-lock.json b/cli/package-lock.json
index e43b8dac..b8b162a2 100644
--- a/cli/package-lock.json
+++ b/cli/package-lock.json
@@ -7,7 +7,7 @@
     "": {
       "name": "@ngirchev/open-daimon",
       "version": "1.0.0",
-      "license": "MIT",
+      "license": "Apache-2.0",
       "dependencies": {
         "@inquirer/prompts": "^7"
       },
diff --git a/cli/package.json b/cli/package.json
index 22ee2988..291fef41 100644
--- a/cli/package.json
+++ b/cli/package.json
@@ -24,8 +24,8 @@
     "openrouter",
     "ollama"
   ],
-  "author": "ngirchev",
-  "license": "MIT",
+  "author": "Nikolai Girchev",
+  "license": "Apache-2.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/NGirchev/open-daimon"
diff --git a/docs/codex/config.example.toml b/docs/codex/config.example.toml
new file mode 100644
index 00000000..ce5a8698
--- /dev/null
+++ b/docs/codex/config.example.toml
@@ -0,0 +1,68 @@
+# Copy selected sections into ~/.codex/config.toml on a workstation that should
+# use the same Codex project setup for OpenDaimon.
+#
+# Keep real user paths and account-specific preferences in ~/.codex/config.toml.
+# Do not commit the copied file back to the repository.
+
+model = "gpt-5.5"
+model_reasoning_effort = "high"
+plan_mode_reasoning_effort = "xhigh"
+service_tier = "fast"
+
+[projects."<absolute-path-to-open-daimon>"]
+trust_level = "trusted"
+
+[features]
+codex_hooks = true
+memories = true
+terminal_resize_reflow = true
+
+[tui]
+status_line = [
+  "model-with-reasoning",
+  "context-remaining",
+  "current-dir",
+  "model-name",
+  "project-root",
+  "git-branch",
+  "five-hour-limit",
+  "weekly-limit",
+  "used-tokens",
+  "total-input-tokens",
+  "total-output-tokens"
+]
+
+[mcp_servers.context7]
+command = "npx"
+args = ["-y", "@upstash/context7-mcp"]
+
+[mcp_servers.serena]
+command = "uvx"
+args = [
+  "--from",
+  "git+https://github.com/oraios/serena",
+  "serena",
+  "start-mcp-server",
+  "--context",
+  "codex",
+  "--project-from-cwd"
+]
+
+[mcp_servers.serena.tools.edit_memory]
+approval_mode = "approve"
+
+[mcp_servers.serena.tools.write_memory]
+approval_mode = "approve"
+
+[mcp_servers.exa]
+url = "https://mcp.exa.ai/mcp"
+
+[mcp_servers.jetbrains]
+command = "npx"
+args = ["-y", "mcp-remote", "http://127.0.0.1:64342/sse"]
+
+[mcp_servers.jetbrains.tools.get_project_modules]
+approval_mode = "approve"
+
+[mcp_servers.jetbrains.tools.get_all_open_file_paths]
+approval_mode = "approve"
diff --git a/docs/codex/mcp.example.json b/docs/codex/mcp.example.json
new file mode 100644
index 00000000..3176e1d3
--- /dev/null
+++ b/docs/codex/mcp.example.json
@@ -0,0 +1,34 @@
+{
+  "mcpServers": {
+    "context7": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@upstash/context7-mcp"
+      ]
+    },
+    "serena": {
+      "command": "uvx",
+      "args": [
+        "--from",
+        "git+https://github.com/oraios/serena",
+        "serena",
+        "start-mcp-server",
+        "--context",
+        "codex",
+        "--project-from-cwd"
+      ]
+    },
+    "exa": {
+      "url": "https://mcp.exa.ai/mcp"
+    },
+    "jetbrains": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "mcp-remote",
+        "http://127.0.0.1:64342/sse"
+      ]
+    }
+  }
+}
diff --git a/docs/codex/serena.example.yml b/docs/codex/serena.example.yml
new file mode 100644
index 00000000..67fc49e5
--- /dev/null
+++ b/docs/codex/serena.example.yml
@@ -0,0 +1,29 @@
+# Copy selected values into ~/.serena/serena_config.yml.
+# This file is a workstation template, not a repository runtime config.
+
+language_backend: LSP
+line_ending: native
+
+gui_log_window: false
+web_dashboard: true
+web_dashboard_listen_address: 127.0.0.1
+web_dashboard_open_on_launch: false
+web_dashboard_interface:
+
+jetbrains_plugin_server_address: 127.0.0.1
+log_level: 20
+trace_lsp_communication: false
+tool_timeout: 240
+default_max_tool_answer_chars: 150000
+token_count_estimator: CHAR_COUNT
+symbol_info_budget: 10
+
+project_serena_folder_location: "$projectDir/.serena"
+
+default_modes:
+  - interactive
+  - editing
+
+# Optional. Serena updates this list automatically after activation.
+projects:
+  - <absolute-path-to-open-daimon>
diff --git a/docs/codex/setup.md b/docs/codex/setup.md
new file mode 100644
index 00000000..a878d0e4
--- /dev/null
+++ b/docs/codex/setup.md
@@ -0,0 +1,129 @@
+# Codex Workstation Setup
+
+This guide documents the project-specific Codex, MCP, and Serena setup needed to work on OpenDaimon from a new machine.
+
+Do not commit personal global files such as `~/.codex/config.toml`, `~/.codex/hooks.json`, or `~/.serena/serena_config.yml`. This repository keeps portable examples and project instructions instead.
+
+## What Is Versioned
+
+- `AGENTS.md` contains the project instructions for Codex and other coding agents.
+- `.serena/project.yml` contains the shared Serena project configuration.
+- `.serena/memories/` contains curated project memories that are safe to share.
+- `docs/codex/mcp.example.json` is a portable MCP example for clients that support repo-local MCP config.
+- `docs/codex/config.example.toml` is a template for the relevant `~/.codex/config.toml` sections.
+- `docs/codex/serena.example.yml` is a template for the relevant `~/.serena/serena_config.yml` values.
+
+The local `.mcp.json`, `.serena/project.local.yml`, `.serena/cache/`, and OS/editor artifacts stay ignored.
+
+## Prerequisites
+
+Install the normal project toolchain first:
+
+- Java 21
+- Maven wrapper support through `./mvnw`
+- Docker, for integration tests and local runtime dependencies
+- Node.js with `npx`, for Context7 and JetBrains MCP bridge
+- `uvx`, for Serena
+- `rg`, for fast repository search
+- `ast-outline`, optional but recommended because `AGENTS.md` asks agents to use it for structural pre-reads
+
+For JetBrains MCP, open the project in a JetBrains IDE with the MCP plugin enabled. The documented bridge expects the plugin SSE endpoint at `http://127.0.0.1:64342/sse`.
+
+## Codex Global Config
+
+Copy the relevant sections from `docs/codex/config.example.toml` into `~/.codex/config.toml`.
+
+Replace:
+
+- `<absolute-path-to-open-daimon>` with the real checkout path on that machine.
+
+Keep API keys and personal preferences out of repository files. If a server requires authentication, configure it through the normal global Codex or provider-specific mechanism on that workstation.
+
+The important MCP servers for this project are:
+
+- `serena`, for project-aware symbol navigation and memories.
+- `jetbrains`, for IDE-indexed Java navigation and inspections.
+- `context7`, for current framework and library docs.
+- `exa`, for web research when needed.
+
+Restart Codex after editing `~/.codex/config.toml`. MCP discovery is session-scoped, so changed servers usually do not appear in an already-running session.
+
+## Repo-Local MCP Option
+
+If the Codex build or another MCP-aware client supports repo-local `.mcp.json`, create a local copy:
+
+```bash
+cp docs/codex/mcp.example.json .mcp.json
+```
+
+The committed example uses Serena `--project-from-cwd`, so it does not contain a machine-specific project path.
+
+Keep `.mcp.json` ignored. It is allowed to diverge per machine when a local MCP endpoint, transport, or path differs.
+
+## Serena Global Config
+
+Copy the relevant values from `docs/codex/serena.example.yml` into `~/.serena/serena_config.yml`.
+
+Recommended behavior for this project:
+
+- Keep `project_serena_folder_location: "$projectDir/.serena"` so shared memories live in the checkout.
+- Keep `web_dashboard: true` for diagnostics.
+- Keep `web_dashboard_open_on_launch: false` so Serena does not open a browser tab on every startup.
+- Use `language_backend: LSP` by default. Use JetBrains only when you intentionally want Serena to depend on the IDE backend.
+
+After the first activation, Serena may update the global `projects` list with the machine's real checkout path.
+
+## Hooks And Skills
+
+Codex hooks and skills are workstation-level assets, not OpenDaimon runtime files.
+
+The current local setup uses:
+
+- `~/.codex/hooks.json` for hook orchestration.
+- `~/.codex/skills/continuous-learning-v2` for session observations.
+- Java/OpenDaimon skills such as `fix-java`, `open-daimon-spring-patterns`, `springboot-tdd`, and `springboot-verification`.
+
+Do not vendor those directories into this repository. If another machine should behave the same way, install or sync the Codex skill stack into that machine's `~/.codex/skills`, then enable hooks in the global Codex config:
+
+```toml
+[features]
+codex_hooks = true
+memories = true
+```
+
+Hooks should remain optional for building and testing OpenDaimon. A fresh agent must still be able to work from `AGENTS.md`, the Maven project, and the MCP templates.
+
+## Codex Subagents
+
+Project-level subagent behavior is documented in `AGENTS.md`, not in a committed personal `~/.codex/config.toml`.
+
+For this repository, small explicitly delegated side tasks should use the Spark-backed Codex model:
+
+```text
+model: gpt-5.3-codex-spark
+```
+
+Use it for narrow lookup, verification, or small disjoint patches. Keep larger design work, risky edits, and immediate blockers on the main model unless the user asks for broader delegation.
+
+## Smoke Check
+
+From the repository root, start a new Codex session and check:
+
+```bash
+codex mcp list
+```
+
+Expected MCP servers:
+
+- `context7`
+- `serena`
+- `exa`
+- `jetbrains`, when the JetBrains IDE plugin is running
+
+Then ask Codex to verify that Serena is active for `open-daimon`. If Serena starts but the dashboard does not open automatically, that is expected with the recommended config.
+
+For code verification after edits, keep using the repository rule:
+
+```bash
+./mvnw clean compile
+```
diff --git a/docs/setup-telegram.md b/docs/setup-telegram.md
index 3789c505..e29cc2a0 100644
--- a/docs/setup-telegram.md
+++ b/docs/setup-telegram.md
@@ -27,7 +27,7 @@ Your admin ID is your numeric Telegram user ID. To find it:
    First: John
    ...
    ```
-   The `Id` value is your **`ADMIN_TELEGRAM_ID`**.
+   Put the `Id` value into **`TELEGRAM_ACCESS_ADMIN_IDS`**.
 
 ## Step 3: (Optional) Allow bot in groups
 
@@ -56,5 +56,5 @@ If your token is compromised:
 ## Notes
 
 - The bot will only respond to users listed in `TELEGRAM_ACCESS_*_IDS` or channels in `TELEGRAM_ACCESS_*_CHANNELS`
-- As admin, you are added automatically (via `ADMIN_TELEGRAM_ID`)
+- Add your own user ID to `TELEGRAM_ACCESS_ADMIN_IDS` to get admin access
 - See [User Priorities](../README.md#user-priorities-and-bulkhead) for how access levels work
diff --git a/docs/team/archunit-rules.md b/docs/team/archunit-rules.md
new file mode 100644
index 00000000..8fe08703
--- /dev/null
+++ b/docs/team/archunit-rules.md
@@ -0,0 +1,148 @@
+---
+slug: archunit-rules
+title: "ArchUnit Architecture Rules"
+owner: ngirchev
+created: 2026-04-28
+updated: 2026-05-03
+status: done
+base_branch: fsm
+---
+
+## Summary
+
+OpenDaimon now has executable ArchUnit checks for the core Spring Boot library architecture:
+
+- `opendaimon-app` keeps the cross-module rules: no Spring component-discovery stereotypes in published library modules, no concrete `@Repository` classes, and no cyclic dependencies between `common`, `spring-ai`, `telegram`, and `rest`.
+- `opendaimon-common` keeps common-module rules for stereotypes, configuration placement, property classes, service naming, implementation suffixes, and repository placement.
+- `opendaimon-rest`, `opendaimon-telegram`, and `opendaimon-spring-ai` now each have module-local layer rules.
+
+The rules encode the project style from `AGENTS.md`: library modules are consumed by downstream applications, so bean creation is explicit through configuration classes, configuration properties are kept in `config`, and service layers must not leak controller, handler, DTO, or transport concerns inward.
+
+## Scope
+
+In scope:
+
+- `opendaimon-common`
+- `opendaimon-spring-ai`
+- `opendaimon-telegram`
+- `opendaimon-rest`
+- cross-module checks from `opendaimon-app`
+
+Out of scope:
+
+- `opendaimon-ui`
+- `opendaimon-gateway-mock`
+- application runtime wiring beyond the existing cross-module `ArchitectureTest`
+
+`opendaimon-ui` and `opendaimon-gateway-mock` are intentionally out of scope for module-local ArchUnit suites. They are thin support modules without independent repository/domain/service layering. For those modules, use compile checks, dependency analysis/enforcer checks, and focused behavior tests when behavior changes. Reconsider ArchUnit only if either module grows stable internal architectural boundaries that need executable enforcement.
+
+## Rule Set
+
+### Cross-Module Rules
+
+File: `opendaimon-app/src/test/java/io/github/ngirchev/opendaimon/arch/ArchitectureTest.java`
+
+- Published library modules must not use `@Service` or `@Component`.
+- Concrete classes must not use `@Repository`; Spring Data repository interfaces remain allowed.
+- Library modules must not form package-level dependency cycles.
+- `IncludeOpendaimonOnly` keeps ArchUnit import behavior stable across both `mvn test` and `mvn verify -Pfixture` by allowing exploded classes and only project-owned `opendaimon-*` JARs.
+
+### Common Rules
+
+File: `opendaimon-common/src/test/java/io/github/ngirchev/opendaimon/common/arch/CommonArchitectureTest.java`
+
+- No `@Service` or `@Component`.
+- Configuration classes and `@Bean` methods stay under `common.config`.
+- `@ConfigurationProperties` classes stay under `common.config`, end with `Properties`, and use validation.
+- Services live under `common.service`, service implementations end with `Impl`, and interfaces stay interface-only.
+- Repository access is limited to repository and service layers.
+
+### REST Rules
+
+File: `opendaimon-rest/src/test/java/io/github/ngirchev/opendaimon/rest/arch/RestArchitectureTest.java`
+
+- No `@Service` or `@Component`.
+- No concrete `@Repository` classes.
+- `@Bean`, `@Configuration`, and `@AutoConfiguration` classes stay under `rest.config`.
+- `@ConfigurationProperties` classes stay under `rest.config`, end with `Properties`, and use validation.
+- `@RestController` classes stay under `rest.controller`.
+- `@ControllerAdvice` and `@RestControllerAdvice` classes stay under `rest.exception`.
+- Repository access is limited to config, repository, and service layers.
+- `rest.service..` does not depend on `rest.dto..` or `rest.handler..`.
+
+Implementation cleanup required for these rules:
+
+- `RestChatCommand` and `RestChatCommandType` moved from `rest.handler` to `rest.command`.
+- REST service return types were split into internal service models under `rest.service.model`.
+- Controllers now map internal service models to public DTOs at the boundary.
+
+### Telegram Rules
+
+File: `opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/arch/TelegramArchitectureTest.java`
+
+- No `@Service` or `@Component`.
+- No concrete `@Repository` classes.
+- `@Bean`, `@Configuration`, and `@AutoConfiguration` classes stay under `telegram.config`.
+- `@ConfigurationProperties` classes stay under `telegram.config`, end with `Properties`, and use validation.
+- Repository access is limited to config, repository, and service layers.
+- `telegram.service..` does not depend on `telegram.command.handler..`.
+
+Implementation cleanup required for these rules:
+
+- Telegram message FSM types moved from `telegram.command.handler.impl.fsm` to `telegram.service.fsm`.
+- `TelegramMessageSender` and `TelegramDeliveryFailedException` moved to `telegram.service`.
+- `TelegramSupportedCommandProvider` moved to `telegram.command`.
+
+### Spring AI Rules
+
+File: `opendaimon-spring-ai/src/test/java/io/github/ngirchev/opendaimon/ai/springai/arch/SpringAIArchitectureTest.java`
+
+- No `@Service` or `@Component`.
+- No concrete `@Repository` classes.
+- `@Bean`, `@Configuration`, and `@AutoConfiguration` classes stay under `ai.springai.config`.
+- `@ConfigurationProperties` classes stay under `ai.springai.config`, end with `Properties`, and use validation.
+- Runtime slices are checked for cycles across `advisor`, `agent`, `embedding`, `memory`, `rag`, `rest`, `retry`, `service`, and `tool`.
+
+Implementation cleanup required for these rules:
+
+- `AgentAutoConfig` moved from `ai.springai.agent` to `ai.springai.config`.
+- `AgentProperties` moved from `ai.springai.agent` to `ai.springai.config`.
+- `OpenRouterModelsProperties` moved from `ai.springai.retry` to `ai.springai.config`.
+- `AutoConfiguration.imports` now references `ai.springai.config.AgentAutoConfig`.
+
+## Maven Wiring
+
+Root `pom.xml` owns the ArchUnit version through `archunit.version`.
+
+The modules with local ArchUnit tests declare ArchUnit test dependencies directly:
+
+- `opendaimon-app`
+- `opendaimon-common`
+- `opendaimon-rest`
+- `opendaimon-telegram`
+- `opendaimon-spring-ai`
+
+Modules that use `archunit-junit5-engine` only through test discovery list it in the Maven dependency plugin's `ignoredUsedUndeclaredDependencies`, matching the existing `opendaimon-common` pattern.
+
+## Verification
+
+Commands used during this cleanup:
+
+```bash
+./mvnw -pl opendaimon-rest -am test -DskipITs -DskipIT
+./mvnw -pl opendaimon-telegram -am test -DskipITs -DskipIT
+./mvnw -pl opendaimon-spring-ai -am test -DskipITs -DskipIT
+```
+
+The final cleanup pass should also run:
+
+```bash
+./mvnw -pl opendaimon-app -am test -Dtest=ArchitectureTest -Dsurefire.failIfNoSpecifiedTests=false -DskipITs -DskipIT
+./mvnw -pl opendaimon-rest -am dependency:analyze -DskipITs -DskipIT
+./mvnw -pl opendaimon-telegram -am dependency:analyze -DskipITs -DskipIT
+./mvnw -pl opendaimon-spring-ai -am dependency:analyze -DskipITs -DskipIT
+```
+
+## Status
+
+Done when all module-local ArchUnit suites and dependency analysis checks pass, and no references remain to the old package locations for moved REST, Telegram, and Spring AI types.
diff --git a/docs/usecases/doc-xls-tika-rag.md b/docs/usecases/doc-xls-tika-rag.md
index 1707077a..7bb55566 100644
--- a/docs/usecases/doc-xls-tika-rag.md
+++ b/docs/usecases/doc-xls-tika-rag.md
@@ -4,7 +4,9 @@
 > - `DocRagOllamaManualIT`, `DocRagOpenRouterManualIT` — DOC files
 > - `XlsRagOllamaManualIT`, `XlsRagOpenRouterManualIT` — XLS files
 >
-> Run with: `./mvnw -pl opendaimon-app -am clean test-compile failsafe:integration-test failsafe:verify -Dit.test=<TestClass> -Dfailsafe.failIfNoSpecifiedTests=false -Dmanual.ollama.e2e=true`
+> Run with `-Dmanual.ollama.e2e=true` for `*OllamaManualIT` classes or
+> `-Dmanual.openrouter.e2e=true` for `*OpenRouterManualIT` classes:
+> `./mvnw -pl opendaimon-app -am clean test-compile failsafe:integration-test failsafe:verify -Dit.test=<TestClass> -Dfailsafe.failIfNoSpecifiedTests=false ...`
 
 When a user uploads a DOC, XLS, DOCX, XLSX or other office document, the system extracts
 text via Apache Tika (through Spring AI's `TikaDocumentReader`), indexes chunks in
diff --git a/docs/usecases/image-pdf-vision-cache.md b/docs/usecases/image-pdf-vision-cache.md
index 4fa14027..63f34fac 100644
--- a/docs/usecases/image-pdf-vision-cache.md
+++ b/docs/usecases/image-pdf-vision-cache.md
@@ -3,9 +3,11 @@
 > **Fixture test:** `ImagePdfVisionCacheFixtureIT` — run with `./mvnw clean verify -pl opendaimon-app -am -Pfixture`
 >
 > **Manual tests:**
-> - `ImagePdfVisionRagOllamaManualIT` — `image-based-pdf-sample.pdf` with OCR via gemma3:4b
+> - `ImagePdfVisionRagOllamaManualIT`, `ImagePdfVisionRagOpenRouterManualIT` — `image-based-pdf-sample.pdf` with OCR via a vision model
 >
-> Run with: `./mvnw -pl opendaimon-app -am clean test-compile failsafe:integration-test failsafe:verify -Dit.test=ImagePdfVisionRagOllamaManualIT -Dfailsafe.failIfNoSpecifiedTests=false -Dmanual.ollama.e2e=true`
+> Run with `-Dmanual.ollama.e2e=true` for `ImagePdfVisionRagOllamaManualIT` or
+> `-Dmanual.openrouter.e2e=true` for `ImagePdfVisionRagOpenRouterManualIT`:
+> `./mvnw -pl opendaimon-app -am clean test-compile failsafe:integration-test failsafe:verify -Dit.test=<TestClass> -Dfailsafe.failIfNoSpecifiedTests=false ...`
 
 When a user uploads an image-only PDF (scan, certificate, etc.), the system detects it
 before the gateway call, renders pages as images, extracts text via a vision-capable model,
diff --git a/docs/usecases/image-vision-direct.md b/docs/usecases/image-vision-direct.md
index bca42237..aee3190f 100644
--- a/docs/usecases/image-vision-direct.md
+++ b/docs/usecases/image-vision-direct.md
@@ -4,7 +4,9 @@
 > - `ObjectsImageVisionOllamaManualIT`, `ObjectsImageVisionOpenRouterManualIT` — photo of objects
 > - `GreekImageVisionOllamaManualIT`, `GreekImageVisionOpenRouterManualIT` — image with Greek text
 >
-> Run with: `./mvnw -pl opendaimon-app -am clean test-compile failsafe:integration-test failsafe:verify -Dit.test=<TestClass> -Dfailsafe.failIfNoSpecifiedTests=false -Dmanual.ollama.e2e=true`
+> Run with `-Dmanual.ollama.e2e=true` for `*OllamaManualIT` classes or
+> `-Dmanual.openrouter.e2e=true` for `*OpenRouterManualIT` classes:
+> `./mvnw -pl opendaimon-app -am clean test-compile failsafe:integration-test failsafe:verify -Dit.test=<TestClass> -Dfailsafe.failIfNoSpecifiedTests=false ...`
 
 When a user uploads a JPEG/PNG image (not a PDF), the system sends it directly to a
 vision-capable model as a `Media` object. **No RAG indexing is performed** — images bypass
diff --git a/docs/usecases/text-pdf-rag.md b/docs/usecases/text-pdf-rag.md
index f9e7c0fa..c72d1497 100644
--- a/docs/usecases/text-pdf-rag.md
+++ b/docs/usecases/text-pdf-rag.md
@@ -6,7 +6,9 @@
 > - `TextPdfRagOllamaManualIT`, `TextPdfRagOpenRouterManualIT` — single-page `sample.pdf` with follow-up RAG
 > - `ImagesWithTextPdfVisionRagOllamaManualIT`, `ImagesWithTextPdfVisionRagOpenRouterManualIT` — 3-page `images_with_text.pdf` with cross-chunk RAG retrieval
 >
-> Run with: `./mvnw -pl opendaimon-app -am clean test-compile failsafe:integration-test failsafe:verify -Dit.test=<TestClass> -Dfailsafe.failIfNoSpecifiedTests=false -Dmanual.ollama.e2e=true`
+> Run with `-Dmanual.ollama.e2e=true` for `*OllamaManualIT` classes or
+> `-Dmanual.openrouter.e2e=true` for `*OpenRouterManualIT` classes:
+> `./mvnw -pl opendaimon-app -am clean test-compile failsafe:integration-test failsafe:verify -Dit.test=<TestClass> -Dfailsafe.failIfNoSpecifiedTests=false ...`
 
 When a user uploads a PDF with a text layer (selectable text), the system extracts text
 via PDFBox, indexes chunks in VectorStore, and builds an augmented prompt for the LLM.
diff --git a/opendaimon-app/pom.xml b/opendaimon-app/pom.xml
index e6d4335d..a8aa63eb 100644
--- a/opendaimon-app/pom.xml
+++ b/opendaimon-app/pom.xml
@@ -27,36 +27,41 @@
 
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
-
-        <pdfbox.version>3.0.5</pdfbox.version>
     </properties>
 
     <dependencies>
-        <!-- Project Dependencies -->
+        <!-- Internal modules: runtime composition of OpenDaimon. main code does not
+             import them directly; their auto-configs activate at runtime, and IT tests
+             use their @Bean types via Spring DI. -->
         <dependency>
             <groupId>io.github.ngirchev</groupId>
             <artifactId>opendaimon-telegram</artifactId>
             <version>${project.version}</version>
+            <scope>runtime</scope>
         </dependency>
         <dependency>
             <groupId>io.github.ngirchev</groupId>
             <artifactId>opendaimon-rest</artifactId>
             <version>${project.version}</version>
+            <scope>runtime</scope>
         </dependency>
         <dependency>
             <groupId>io.github.ngirchev</groupId>
             <artifactId>opendaimon-ui</artifactId>
             <version>${project.version}</version>
+            <scope>runtime</scope>
         </dependency>
         <dependency>
             <groupId>io.github.ngirchev</groupId>
             <artifactId>opendaimon-spring-ai</artifactId>
             <version>${project.version}</version>
+            <scope>runtime</scope>
         </dependency>
         <dependency>
             <groupId>io.github.ngirchev</groupId>
             <artifactId>opendaimon-gateway-mock</artifactId>
             <version>${project.version}</version>
+            <scope>runtime</scope>
         </dependency>
 
         <dependency>
@@ -64,39 +69,62 @@
             <artifactId>dotenv</artifactId>
         </dependency>
 
-        <!-- Spring Boot-->
+        <!-- Spring Boot core (Application class) -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-autoconfigure</artifactId>
+        </dependency>
+
+        <!-- Spring core (FlywayConfig @Configuration) -->
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-context</artifactId>
+        </dependency>
+
+        <!-- Boot starters (autoconfig glue, not directly imported) -->
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-validation</artifactId>
+            <scope>runtime</scope>
         </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-data-jpa</artifactId>
+            <scope>runtime</scope>
         </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-web</artifactId>
+            <scope>runtime</scope>
         </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-actuator</artifactId>
+            <scope>runtime</scope>
         </dependency>
-
-        <!-- Swagger -->
+        <!-- Redis (optional in opendaimon-telegram, must be explicitly included for runtime) -->
         <dependency>
-            <groupId>org.springdoc</groupId>
-            <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-redis</artifactId>
+            <scope>runtime</scope>
         </dependency>
 
+        <!-- Swagger UI (autoconfig only) -->
         <dependency>
-            <groupId>jakarta.xml.bind</groupId>
-            <artifactId>jakarta.xml.bind-api</artifactId>
+            <groupId>org.springdoc</groupId>
+            <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
+            <scope>runtime</scope>
         </dependency>
 
-        <!-- Database dependencies -->
+        <!-- Database (runtime drivers + Flyway plugin) -->
         <dependency>
             <groupId>org.postgresql</groupId>
             <artifactId>postgresql</artifactId>
+            <scope>runtime</scope>
         </dependency>
         <dependency>
             <groupId>org.flywaydb</groupId>
@@ -105,42 +133,83 @@
         <dependency>
             <groupId>org.flywaydb</groupId>
             <artifactId>flyway-database-postgresql</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>com.h2database</groupId>
-            <artifactId>h2</artifactId>
-            <scope>test</scope>
+            <scope>runtime</scope>
         </dependency>
 
-        <dependency>
-            <groupId>org.projectlombok</groupId>
-            <artifactId>lombok</artifactId>
-        </dependency>
-        
         <!-- MinIO (optional in opendaimon-common, must be explicitly included for runtime) -->
         <dependency>
             <groupId>io.minio</groupId>
             <artifactId>minio</artifactId>
-            <version>${minio.version}</version>
+            <scope>runtime</scope>
         </dependency>
-
-        <!-- Redis (optional in opendaimon-telegram, must be explicitly included for runtime) -->
+        <!-- OkHttp (required by MinIO client at runtime) -->
         <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-data-redis</artifactId>
+            <groupId>com.squareup.okhttp3</groupId>
+            <artifactId>okhttp</artifactId>
+            <scope>runtime</scope>
         </dependency>
 
-        <!-- Logstash encoder for sending logs to Logstash via TCP -->
+        <!-- Logging -->
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
+        </dependency>
+        <!-- Logback (used directly in ExceptionMessageConverter) -->
+        <dependency>
+            <groupId>ch.qos.logback</groupId>
+            <artifactId>logback-classic</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>ch.qos.logback</groupId>
+            <artifactId>logback-core</artifactId>
+        </dependency>
+        <!-- Logstash encoder for sending logs to Logstash via TCP (runtime config only) -->
         <dependency>
             <groupId>net.logstash.logback</groupId>
             <artifactId>logstash-logback-encoder</artifactId>
-            <version>7.4</version>
+            <scope>runtime</scope>
         </dependency>
 
-        <!-- test-->
+        <!-- Lombok -->
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <scope>provided</scope>
+            <optional>true</optional>
+        </dependency>
+
+        <!-- PDFBox (runtime, used by spring-ai-pdf-document-reader) -->
+        <dependency>
+            <groupId>org.apache.pdfbox</groupId>
+            <artifactId>pdfbox</artifactId>
+            <scope>runtime</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.pdfbox</groupId>
+            <artifactId>pdfbox-io</artifactId>
+            <scope>runtime</scope>
+            <exclusions>
+                <exclusion>
+                    <groupId>commons-logging</groupId>
+                    <artifactId>commons-logging</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+
+        <!-- Test -->
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-test</artifactId>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-test</artifactId>
+            <artifactId>spring-boot-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-test-autoconfigure</artifactId>
             <scope>test</scope>
         </dependency>
         <dependency>
@@ -148,6 +217,26 @@
             <artifactId>spring-boot-testcontainers</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-engine</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>org.testcontainers</groupId>
             <artifactId>testcontainers</artifactId>
@@ -164,26 +253,70 @@
             <scope>test</scope>
         </dependency>
         <dependency>
-            <groupId>com.squareup.okhttp3</groupId>
-            <artifactId>mockwebserver</artifactId>
+            <groupId>com.h2database</groupId>
+            <artifactId>h2</artifactId>
             <scope>test</scope>
         </dependency>
-        <!-- PDFBox for RAG (runtime, used by spring-ai-pdf-document-reader) -->
         <dependency>
-            <groupId>org.apache.pdfbox</groupId>
-            <artifactId>pdfbox</artifactId>
-            <version>${pdfbox.version}</version>
+            <groupId>com.squareup.okhttp3</groupId>
+            <artifactId>mockwebserver</artifactId>
+            <scope>test</scope>
         </dependency>
         <dependency>
-            <groupId>org.apache.pdfbox</groupId>
-            <artifactId>pdfbox-io</artifactId>
-            <version>${pdfbox.version}</version>
+            <groupId>com.tngtech.archunit</groupId>
+            <artifactId>archunit-junit5</artifactId>
+            <version>${archunit.version}</version>
+            <scope>test</scope>
         </dependency>
-
     </dependencies>
 
     <build>
         <plugins>
+            <!-- opendaimon-app is the runtime composition: IT tests transitively reference
+                 Spring + Spring AI types via internal modules (opendaimon-telegram/rest/ui/spring-ai).
+                 Suppress noise from analyze-only here so the gate stays useful for library
+                 modules without bloating this aggregator's pom with duplicate leaf declarations. -->
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-dependency-plugin</artifactId>
+                <configuration>
+                    <ignoredUsedUndeclaredDependencies>
+                        <ignored>org.springframework:*</ignored>
+                        <ignored>org.springframework.boot:*</ignored>
+                        <ignored>org.springframework.data:*</ignored>
+                        <ignored>org.springframework.ai:*</ignored>
+                        <ignored>org.telegram:*</ignored>
+                        <ignored>io.projectreactor:*</ignored>
+                        <ignored>io.micrometer:*</ignored>
+                        <ignored>io.github.ngirchev:*</ignored>
+                        <ignored>jakarta.persistence:*</ignored>
+                        <ignored>com.tngtech.archunit:*</ignored>
+                    </ignoredUsedUndeclaredDependencies>
+                    <ignoredUnusedDeclaredDependencies>
+                        <ignored>io.github.ngirchev:opendaimon-ui</ignored>
+                        <ignored>org.springframework.boot:spring-boot-starter-*</ignored>
+                        <ignored>org.springdoc:springdoc-openapi-starter-webmvc-ui</ignored>
+                        <ignored>org.postgresql:postgresql</ignored>
+                        <ignored>org.flywaydb:flyway-database-postgresql</ignored>
+                        <ignored>io.minio:minio</ignored>
+                        <ignored>com.squareup.okhttp3:okhttp</ignored>
+                        <ignored>net.logstash.logback:logstash-logback-encoder</ignored>
+                        <ignored>org.apache.pdfbox:pdfbox-io</ignored>
+                        <ignored>org.springframework.boot:spring-boot-testcontainers</ignored>
+                        <!-- JUnit Jupiter engine is required by IDE/JUnit Platform runtime discovery;
+                             test classes import only the API. -->
+                        <ignored>org.junit.jupiter:junit-jupiter-engine</ignored>
+                        <ignored>org.testcontainers:junit-jupiter</ignored>
+                        <ignored>com.h2database:h2</ignored>
+                        <ignored>com.tngtech.archunit:archunit-junit5</ignored>
+                    </ignoredUnusedDeclaredDependencies>
+                    <ignoredNonTestScopedDependencies>
+                        <ignored>org.springframework:spring-core</ignored>
+                        <ignored>org.springframework:spring-beans</ignored>
+                    </ignoredNonTestScopedDependencies>
+                </configuration>
+            </plugin>
+
             <plugin>
                 <groupId>org.springframework.boot</groupId>
                 <artifactId>spring-boot-maven-plugin</artifactId>
diff --git a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/TelegramMessageHandlerActionsTestWiring.java b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/TelegramMessageHandlerActionsTestWiring.java
index 588269ba..ba6b1885 100644
--- a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/TelegramMessageHandlerActionsTestWiring.java
+++ b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/TelegramMessageHandlerActionsTestWiring.java
@@ -7,12 +7,12 @@
 import io.github.ngirchev.opendaimon.common.service.OpenDaimonMessageService;
 import io.github.ngirchev.opendaimon.telegram.TelegramBot;
 import io.github.ngirchev.opendaimon.telegram.command.handler.impl.MessageTelegramCommandHandler;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerContext;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerEvent;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerFsmFactory;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerState;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.TelegramMessageHandlerActions;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.TelegramMessageSender;
+import io.github.ngirchev.opendaimon.telegram.service.fsm.MessageHandlerContext;
+import io.github.ngirchev.opendaimon.telegram.service.fsm.MessageHandlerEvent;
+import io.github.ngirchev.opendaimon.telegram.service.fsm.MessageHandlerFsmFactory;
+import io.github.ngirchev.opendaimon.telegram.service.fsm.MessageHandlerState;
+import io.github.ngirchev.opendaimon.telegram.service.fsm.TelegramMessageHandlerActions;
+import io.github.ngirchev.opendaimon.telegram.service.TelegramMessageSender;
 import io.github.ngirchev.opendaimon.telegram.config.TelegramProperties;
 import io.github.ngirchev.opendaimon.telegram.service.ChatSettingsService;
 import io.github.ngirchev.opendaimon.telegram.service.PersistentKeyboardService;
diff --git a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/config/AgentAutoConfigSmokeIT.java b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/config/AgentAutoConfigSmokeIT.java
index c8e196e8..57f3b15c 100644
--- a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/config/AgentAutoConfigSmokeIT.java
+++ b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/config/AgentAutoConfigSmokeIT.java
@@ -1,6 +1,6 @@
 package io.github.ngirchev.opendaimon.it.config;
 
-import io.github.ngirchev.opendaimon.ai.springai.agent.AgentAutoConfig;
+import io.github.ngirchev.opendaimon.ai.springai.config.AgentAutoConfig;
 import io.github.ngirchev.opendaimon.ai.springai.agent.PlanAndExecuteAgentExecutor;
 import io.github.ngirchev.opendaimon.ai.springai.agent.ReActAgentExecutor;
 import io.github.ngirchev.opendaimon.ai.springai.agent.SimpleChainExecutor;
diff --git a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/config/AppRuntimeDependencyContractIT.java b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/config/AppRuntimeDependencyContractIT.java
new file mode 100644
index 00000000..ac5cdd0e
--- /dev/null
+++ b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/config/AppRuntimeDependencyContractIT.java
@@ -0,0 +1,89 @@
+package io.github.ngirchev.opendaimon.it.config;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.NodeList;
+
+import javax.xml.parsers.DocumentBuilderFactory;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Optional;
+import java.util.jar.JarFile;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Verifies that runtime-only application composition declares the companion
+ * dependencies needed by optional library modules.
+ */
+class AppRuntimeDependencyContractIT {
+
+    @Test
+    @DisplayName("opendaimon-app keeps MinIO runtime dependencies on the packaged classpath")
+    void minioRuntimeDependency_hasOkHttpRuntimeCompanion() throws Exception {
+        Document pom = DocumentBuilderFactory.newInstance()
+                .newDocumentBuilder()
+                .parse(Path.of("pom.xml").toFile());
+
+        Optional<String> minioScope = dependencyScope(pom, "io.minio", "minio");
+        Optional<String> okhttpScope = dependencyScope(pom, "com.squareup.okhttp3", "okhttp");
+
+        assertThat(minioScope)
+                .as("opendaimon-app must include MinIO for runtime storage auto-configuration")
+                .hasValueSatisfying(scope -> assertThat(isRuntimeVisible(scope)).isTrue());
+
+        assertThat(okhttpScope)
+                .as("MinIO constructs MinioClient with okhttp3.RequestBody on the runtime classpath")
+                .hasValueSatisfying(scope -> assertThat(isRuntimeVisible(scope)).isTrue());
+    }
+
+    @Test
+    @DisplayName("opendaimon-app packages Spring AI provider auto-configurations")
+    void springAiRuntimeDependency_hasProviderAutoconfigCompanions() throws Exception {
+        List<String> packagedLibraries = packagedLibraries();
+
+        assertThat(packagedLibraries)
+                .as("OpenAI/OpenRouter models require OpenAiChatAutoConfiguration to create OpenAiChatModel")
+                .anyMatch(name -> name.startsWith("spring-ai-autoconfigure-model-openai-"));
+        assertThat(packagedLibraries)
+                .as("Ollama models require OllamaChatAutoConfiguration to create OllamaChatModel")
+                .anyMatch(name -> name.startsWith("spring-ai-autoconfigure-model-ollama-"));
+    }
+
+    private static Optional<String> dependencyScope(Document pom, String groupId, String artifactId) {
+        NodeList dependencies = pom.getElementsByTagName("dependency");
+        for (int index = 0; index < dependencies.getLength(); index++) {
+            Element dependency = (Element) dependencies.item(index);
+            if (groupId.equals(text(dependency, "groupId"))
+                    && artifactId.equals(text(dependency, "artifactId"))) {
+                return Optional.ofNullable(text(dependency, "scope"));
+            }
+        }
+        return Optional.empty();
+    }
+
+    private static boolean isRuntimeVisible(String scope) {
+        return scope == null || scope.isBlank() || "compile".equals(scope) || "runtime".equals(scope);
+    }
+
+    private static String text(Element element, String tagName) {
+        NodeList nodes = element.getElementsByTagName(tagName);
+        if (nodes.getLength() == 0) {
+            return null;
+        }
+        return nodes.item(0).getTextContent().trim();
+    }
+
+    private static List<String> packagedLibraries() throws Exception {
+        Path jarPath = Path.of("target", "opendaimon-app-1.0.0-SNAPSHOT.jar");
+        try (JarFile jar = new JarFile(jarPath.toFile())) {
+            return jar.stream()
+                    .map(entry -> entry.getName())
+                    .filter(name -> name.startsWith("BOOT-INF/lib/"))
+                    .map(name -> name.substring("BOOT-INF/lib/".length()))
+                    .toList();
+        }
+    }
+}
diff --git a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/config/CoreAutoConfigSmokeIT.java b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/config/CoreAutoConfigSmokeIT.java
index 2fdc51a9..7358dd26 100644
--- a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/config/CoreAutoConfigSmokeIT.java
+++ b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/config/CoreAutoConfigSmokeIT.java
@@ -38,7 +38,7 @@
                 "org.springframework.ai.model.openai.autoconfigure.OpenAiEmbeddingAutoConfiguration," +
                 "org.springframework.ai.model.openai.autoconfigure.OpenAiImageAutoConfiguration," +
                 "io.github.ngirchev.opendaimon.ai.springai.config.SpringAIAutoConfig," +
-                "io.github.ngirchev.opendaimon.ai.springai.agent.AgentAutoConfig," +
+                "io.github.ngirchev.opendaimon.ai.springai.config.AgentAutoConfig," +
                 "io.github.ngirchev.opendaimon.bulkhead.config.BulkHeadAutoConfig," +
                 "io.github.ngirchev.opendaimon.telegram.config.TelegramAutoConfig",
         "open-daimon.common.bulkhead.enabled=false",
diff --git a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/fixture/config/TelegramFixtureConfig.java b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/fixture/config/TelegramFixtureConfig.java
index 2f8d4fe7..ad244852 100644
--- a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/fixture/config/TelegramFixtureConfig.java
+++ b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/fixture/config/TelegramFixtureConfig.java
@@ -30,19 +30,11 @@
 import io.github.ngirchev.opendaimon.telegram.TelegramBot;
 import io.github.ngirchev.opendaimon.it.TelegramMessageHandlerActionsTestWiring;
 import io.github.ngirchev.opendaimon.telegram.command.handler.impl.MessageTelegramCommandHandler;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerContext;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerEvent;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerFsmFactory;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerState;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.TelegramMessageHandlerActions;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.TelegramMessageSender;
-import io.github.ngirchev.fsm.impl.extended.ExDomainFsm;
 import io.github.ngirchev.opendaimon.telegram.config.TelegramProperties;
 import io.github.ngirchev.opendaimon.telegram.repository.TelegramUserRepository;
 import io.github.ngirchev.opendaimon.telegram.repository.TelegramUserSessionRepository;
 import io.github.ngirchev.opendaimon.telegram.service.PersistentKeyboardService;
 import io.github.ngirchev.opendaimon.telegram.service.ReplyImageAttachmentService;
-import io.github.ngirchev.opendaimon.telegram.service.TelegramAgentStreamView;
 import io.github.ngirchev.opendaimon.telegram.service.TelegramChatPacerImpl;
 import io.github.ngirchev.opendaimon.telegram.service.TelegramFileService;
 import io.github.ngirchev.opendaimon.telegram.service.TelegramMessageService;
@@ -237,10 +229,12 @@ public TelegramUserService telegramUserService(
 
     @Bean
     public ObjectProvider<StorageProperties> storagePropertiesProvider() {
-        @SuppressWarnings("unchecked")
-        ObjectProvider<StorageProperties> provider = mock(ObjectProvider.class);
-        when(provider.getIfAvailable()).thenReturn(null);
-        return provider;
+        return new ObjectProvider<>() {
+            @Override
+            public StorageProperties getIfAvailable() {
+                return null;
+            }
+        };
     }
 
     @Bean
diff --git a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/AgentModeOllamaManualIT.java b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/AgentModeOllamaManualIT.java
index 00e14335..bbfef8ec 100644
--- a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/AgentModeOllamaManualIT.java
+++ b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/AgentModeOllamaManualIT.java
@@ -12,6 +12,8 @@
 import io.github.ngirchev.opendaimon.common.model.OpenDaimonMessage;
 import io.github.ngirchev.opendaimon.common.repository.ConversationThreadRepository;
 import io.github.ngirchev.opendaimon.common.repository.OpenDaimonMessageRepository;
+import io.github.ngirchev.opendaimon.it.manual.support.ManualScenarioCache;
+import io.github.ngirchev.opendaimon.it.manual.support.ManualTestPrerequisites;
 import io.github.ngirchev.opendaimon.telegram.TelegramBot;
 import io.github.ngirchev.opendaimon.telegram.command.TelegramCommand;
 import io.github.ngirchev.opendaimon.telegram.command.TelegramCommandType;
@@ -28,12 +30,12 @@
 import okhttp3.mockwebserver.MockWebServer;
 import okhttp3.mockwebserver.RecordedRequest;
 import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.api.Assumptions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
 import org.junit.jupiter.api.Timeout;
 import org.junit.jupiter.api.condition.EnabledIfSystemProperty;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -52,10 +54,6 @@
 import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
 
 import java.io.IOException;
-import java.net.URI;
-import java.net.http.HttpClient;
-import java.net.http.HttpRequest;
-import java.net.http.HttpResponse;
 import lombok.extern.slf4j.Slf4j;
 
 import java.time.Duration;
@@ -71,7 +69,6 @@
 import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.atLeastOnce;
 import static org.mockito.Mockito.doNothing;
 import static org.mockito.Mockito.reset;
 import static org.mockito.Mockito.verify;
@@ -104,6 +101,7 @@
 @EnabledIfSystemProperty(named = "manual.ollama.e2e", matches = "true")
 @SpringBootTest(classes = AgentModeOllamaManualIT.TestConfig.class)
 @ActiveProfiles({"integration-test", "manual-ollama"})
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
 @Slf4j
 class AgentModeOllamaManualIT extends AbstractContainerIT {
 
@@ -136,6 +134,11 @@ class AgentModeOllamaManualIT extends AbstractContainerIT {
 
     private static final MockWebServer mockWebServer = createMockWebServer();
 
+    private final ManualScenarioCache<HandledCommandResult> adminReactWebSearchScenario =
+            ManualScenarioCache.of(this::runAdminReactWebSearchScenario);
+    private final ManualScenarioCache<HandledCommandResult> regularSimpleScenario =
+            ManualScenarioCache.of(this::runRegularSimpleScenario);
+
     @Autowired
     private MessageTelegramCommandHandler messageHandler;
 
@@ -165,7 +168,7 @@ class AgentModeOllamaManualIT extends AbstractContainerIT {
 
     @BeforeAll
     static void checkOllama() {
-        requireLocalOllamaWithModels();
+        ManualTestPrerequisites.requireLocalOllamaWithModels(REQUIRED_OLLAMA_MODELS, OLLAMA_TIMEOUT);
     }
 
     @AfterAll
@@ -200,21 +203,7 @@ void setUpEach() throws TelegramApiException {
     @Test
     @Timeout(3 * 60)
     @DisplayName("ADMIN: agent uses REACT strategy and invokes web_search tool")
-    void admin_agentReact_invokesWebSearch() {
-        TelegramCommand command = createMessageCommand(
-                ADMIN_CHAT_ID,
-                1,
-                "Какая последняя версия Spring Boot вышла в 2026 году? Поищи в интернете."
-        );
-
-        messageHandler.handle(command);
-
-        TelegramUser user = telegramUserRepository.findByTelegramId(ADMIN_CHAT_ID)
-                .orElseThrow(() -> new IllegalStateException("Telegram user should be created"));
-
-        ConversationThread thread = threadRepository.findMostRecentActiveThread(user)
-                .orElseThrow(() -> new IllegalStateException("Active thread should exist"));
-
+    void admin_agentReact_invokesWebSearch() throws Exception {
         // The primary goal of this test is to verify that ADMIN users activate
         // REACT strategy (not SIMPLE). With a 3B model, the LLM may occasionally:
         //   - invoke tools and produce a response (ideal path)
@@ -222,10 +211,9 @@ void admin_agentReact_invokesWebSearch() {
         //   - return an empty response causing agent FAILED state (known 3B quirk)
         // All three outcomes confirm that REACT was activated and the pipeline
         // ran end-to-end. We verify at least one assistant message was persisted.
-        List<OpenDaimonMessage> assistantMessages = messageRepository
-                .findByThreadAndRoleOrderBySequenceNumberAsc(thread, MessageRole.ASSISTANT);
+        HandledCommandResult result = adminReactWebSearchScenario.get();
 
-        assertThat(assistantMessages)
+        assertThat(result.assistantMessages())
                 .as("Handler must save an assistant message (even on agent FAILED state)")
                 .isNotEmpty();
     }
@@ -235,32 +223,18 @@ void admin_agentReact_invokesWebSearch() {
     @Test
     @Timeout(3 * 60)
     @DisplayName("REGULAR: agent uses SIMPLE strategy without tools")
-    void regular_agentSimple_noTools() {
-        TelegramCommand command = createMessageCommand(
-                REGULAR_CHAT_ID,
-                2,
-                "Привет, расскажи анекдот"
-        );
-
-        messageHandler.handle(command);
-
-        TelegramUser user = telegramUserRepository.findByTelegramId(REGULAR_CHAT_ID)
-                .orElseThrow(() -> new IllegalStateException("Telegram user should be created"));
-
-        ConversationThread thread = threadRepository.findMostRecentActiveThread(user)
-                .orElseThrow(() -> new IllegalStateException("Active thread should exist"));
-
-        String assistantReply = latestAssistantReply(thread);
+    void regular_agentSimple_noTools() throws Exception {
+        HandledCommandResult result = regularSimpleScenario.get();
 
-        assertThat(assistantReply)
+        assertThat(result.assistantReply())
                 .as("SIMPLE agent should produce a non-blank response")
                 .isNotBlank();
 
-        assertThat(WEB_SEARCH_CALLED.get())
+        assertThat(result.webSearchCalled())
                 .as("REGULAR (CHAT-only) should NOT invoke web_search")
                 .isFalse();
 
-        assertThat(FETCH_URL_CALLED.get())
+        assertThat(result.fetchUrlCalled())
                 .as("REGULAR (CHAT-only) should NOT invoke fetch_url")
                 .isFalse();
     }
@@ -270,35 +244,18 @@ void regular_agentSimple_noTools() {
     @Test
     @Timeout(3 * 60)
     @DisplayName("Agent response saved to DB with correct structure")
-    void agentResponse_persistedToDb() {
-        TelegramCommand command = createMessageCommand(
-                ADMIN_CHAT_ID,
-                3,
-                "Скажи одним словом: работает ли агент?"
-        );
-
-        messageHandler.handle(command);
-
-        TelegramUser user = telegramUserRepository.findByTelegramId(ADMIN_CHAT_ID)
-                .orElseThrow();
+    void agentResponse_persistedToDb() throws Exception {
+        HandledCommandResult result = regularSimpleScenario.get();
 
-        ConversationThread thread = threadRepository.findMostRecentActiveThread(user)
-                .orElseThrow();
-
-        List<OpenDaimonMessage> userMessages = messageRepository
-                .findByThreadAndRoleOrderBySequenceNumberAsc(thread, MessageRole.USER);
-        List<OpenDaimonMessage> assistantMessages = messageRepository
-                .findByThreadAndRoleOrderBySequenceNumberAsc(thread, MessageRole.ASSISTANT);
-
-        assertThat(userMessages)
+        assertThat(result.userMessages())
                 .as("User message should be saved")
                 .hasSize(1);
 
-        assertThat(assistantMessages)
+        assertThat(result.assistantMessages())
                 .as("Assistant message should be saved")
                 .hasSize(1);
 
-        assertThat(assistantMessages.getFirst().getContent())
+        assertThat(result.assistantMessages().getFirst().getContent())
                 .as("Assistant content should not be blank")
                 .isNotBlank();
     }
@@ -706,6 +663,47 @@ void admin_reactStrategy_thinkingAndToolCallSentToTelegram() throws TelegramApiE
 
     // --- Helpers ---
 
+    private HandledCommandResult runAdminReactWebSearchScenario() {
+        TelegramCommand command = createMessageCommand(
+                ADMIN_CHAT_ID,
+                1,
+                "Какая последняя версия Spring Boot вышла в 2026 году? Поищи в интернете."
+        );
+        return handleCommand(command, ADMIN_CHAT_ID);
+    }
+
+    private HandledCommandResult runRegularSimpleScenario() {
+        TelegramCommand command = createMessageCommand(
+                REGULAR_CHAT_ID,
+                2,
+                "Привет, расскажи анекдот"
+        );
+        return handleCommand(command, REGULAR_CHAT_ID);
+    }
+
+    private HandledCommandResult handleCommand(TelegramCommand command, Long chatId) {
+        messageHandler.handle(command);
+
+        TelegramUser user = telegramUserRepository.findByTelegramId(chatId)
+                .orElseThrow(() -> new IllegalStateException("Telegram user should be created"));
+        ConversationThread thread = threadRepository.findMostRecentActiveThread(user)
+                .orElseThrow(() -> new IllegalStateException("Active thread should exist"));
+        List<OpenDaimonMessage> userMessages = messageRepository
+                .findByThreadAndRoleOrderBySequenceNumberAsc(thread, MessageRole.USER);
+        List<OpenDaimonMessage> assistantMessages = messageRepository
+                .findByThreadAndRoleOrderBySequenceNumberAsc(thread, MessageRole.ASSISTANT);
+        String assistantReply = assistantMessages.isEmpty() ? "" : assistantMessages.getLast().getContent();
+        return new HandledCommandResult(
+                userMessages,
+                assistantMessages,
+                assistantReply,
+                WEB_SEARCH_CALLED.get(),
+                FETCH_URL_CALLED.get(),
+                HTTP_GET_CALLED.get(),
+                TOOL_CALL_COUNT.get()
+        );
+    }
+
     private TelegramCommand createMessageCommand(Long chatId, int messageId, String text) {
         Update update = new Update();
 
@@ -783,37 +781,15 @@ private static MockWebServer createMockWebServer() {
         return server;
     }
 
-    static void requireLocalOllamaWithModels() {
-        String baseUrl = resolveOllamaBaseUrl();
-        HttpClient client = HttpClient.newBuilder()
-                .connectTimeout(OLLAMA_TIMEOUT)
-                .build();
-        HttpRequest request = HttpRequest.newBuilder()
-                .GET()
-                .timeout(OLLAMA_TIMEOUT)
-                .uri(URI.create(baseUrl + "/api/tags"))
-                .build();
-        try {
-            HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
-            boolean statusOk = response.statusCode() == 200;
-            boolean modelsPresent = REQUIRED_OLLAMA_MODELS.stream().allMatch(response.body()::contains);
-            Assumptions.assumeTrue(statusOk && modelsPresent,
-                    "Skipping: Ollama/models unavailable at " + baseUrl + ". Required: " + REQUIRED_OLLAMA_MODELS);
-        } catch (Exception ex) {
-            Assumptions.assumeTrue(false,
-                    "Skipping: cannot connect to Ollama at " + baseUrl + ". " + ex.getMessage());
-        }
-    }
-
-    private static String resolveOllamaBaseUrl() {
-        String baseUrl = System.getenv("OLLAMA_BASE_URL");
-        if (baseUrl == null || baseUrl.isBlank()) {
-            baseUrl = "http://localhost:11434";
-        }
-        if (baseUrl.endsWith("/")) {
-            return baseUrl.substring(0, baseUrl.length() - 1);
-        }
-        return baseUrl;
+    private record HandledCommandResult(
+            List<OpenDaimonMessage> userMessages,
+            List<OpenDaimonMessage> assistantMessages,
+            String assistantReply,
+            boolean webSearchCalled,
+            boolean fetchUrlCalled,
+            boolean httpGetCalled,
+            int toolCallCount
+    ) {
     }
 
     @SpringBootConfiguration
diff --git a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/AgentModeOpenRouterManualIT.java b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/AgentModeOpenRouterManualIT.java
index 295871bd..648b42fb 100644
--- a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/AgentModeOpenRouterManualIT.java
+++ b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/AgentModeOpenRouterManualIT.java
@@ -1,6 +1,5 @@
 package io.github.ngirchev.opendaimon.it.manual;
 
-import io.github.ngirchev.dotenv.DotEnvLoader;
 import io.github.ngirchev.opendaimon.ai.springai.tool.HttpApiTool;
 import io.github.ngirchev.opendaimon.ai.springai.tool.WebTools;
 import io.github.ngirchev.opendaimon.common.agent.AgentExecutor;
@@ -9,6 +8,8 @@
 import io.github.ngirchev.opendaimon.common.model.OpenDaimonMessage;
 import io.github.ngirchev.opendaimon.common.repository.ConversationThreadRepository;
 import io.github.ngirchev.opendaimon.common.repository.OpenDaimonMessageRepository;
+import io.github.ngirchev.opendaimon.it.manual.support.ManualScenarioCache;
+import io.github.ngirchev.opendaimon.it.manual.support.ManualTestPrerequisites;
 import io.github.ngirchev.opendaimon.telegram.TelegramBot;
 import io.github.ngirchev.opendaimon.telegram.command.TelegramCommand;
 import io.github.ngirchev.opendaimon.telegram.command.TelegramCommandType;
@@ -25,12 +26,12 @@
 import okhttp3.mockwebserver.MockWebServer;
 import okhttp3.mockwebserver.RecordedRequest;
 import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.api.Assumptions;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
 import org.junit.jupiter.api.Timeout;
 import org.junit.jupiter.api.condition.EnabledIfSystemProperty;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -49,7 +50,6 @@
 import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
 
 import java.io.IOException;
-import java.nio.file.Path;
 import java.time.Duration;
 import java.util.List;
 import java.util.Set;
@@ -107,12 +107,9 @@
         }
 )
 @ActiveProfiles({"integration-test", "manual-openrouter"})
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
 class AgentModeOpenRouterManualIT extends AbstractContainerIT {
 
-    static {
-        DotEnvLoader.loadDotEnv(Path.of("../.env"));
-    }
-
     private static final Long ADMIN_CHAT_ID = 350009010L;
     private static final Long REGULAR_CHAT_ID = 350009012L;
 
@@ -135,6 +132,11 @@ class AgentModeOpenRouterManualIT extends AbstractContainerIT {
 
     private static final MockWebServer mockWebServer = createMockWebServer();
 
+    private final ManualScenarioCache<HandledCommandResult> adminReactWebSearchScenario =
+            ManualScenarioCache.of(this::runAdminReactWebSearchScenario);
+    private final ManualScenarioCache<HandledCommandResult> regularSimpleScenario =
+            ManualScenarioCache.of(this::runRegularSimpleScenario);
+
     @Autowired
     private MessageTelegramCommandHandler messageHandler;
 
@@ -164,12 +166,7 @@ class AgentModeOpenRouterManualIT extends AbstractContainerIT {
 
     @BeforeAll
     static void requireOpenRouterKey() {
-        DotEnvLoader.loadDotEnv(Path.of("../.env"));
-        String openRouterKey = System.getProperty("OPENROUTER_KEY", System.getenv("OPENROUTER_KEY"));
-        Assumptions.assumeTrue(
-                openRouterKey != null && !openRouterKey.isBlank() && !openRouterKey.equals("sk-placeholder"),
-                "Skipping manual test: OPENROUTER_KEY not set in .env or environment"
-        );
+        ManualTestPrerequisites.requireOpenRouterKey();
     }
 
     @AfterAll
@@ -200,30 +197,13 @@ void setUpEach() throws TelegramApiException {
     @Test
     @Timeout(3 * 60)
     @DisplayName("B1: ADMIN agent uses REACT strategy and invokes web_search via OpenRouter")
-    void admin_agentReact_invokesWebSearch() {
-        TelegramCommand command = createMessageCommand(
-                ADMIN_CHAT_ID,
-                1,
-                "What is the latest version of Spring Boot released in 2026? Search the internet."
-        );
-
-        messageHandler.handle(command);
-
-        TelegramUser user = telegramUserRepository.findByTelegramId(ADMIN_CHAT_ID)
-                .orElseThrow(() -> new IllegalStateException("Telegram user should be created"));
-
-        ConversationThread thread = threadRepository.findMostRecentActiveThread(user)
-                .orElseThrow(() -> new IllegalStateException("Active thread should exist"));
-
-        String assistantReply = latestAssistantReply(thread);
-
+    void admin_agentReact_invokesWebSearch() throws Exception {
         // The primary goal is to verify that ADMIN activates REACT strategy.
         // LLM may occasionally return an empty response (known quirk in batch runs).
         // All outcomes confirm the pipeline ran end-to-end.
-        List<OpenDaimonMessage> assistantMessages = messageRepository
-                .findByThreadAndRoleOrderBySequenceNumberAsc(thread, MessageRole.ASSISTANT);
+        HandledCommandResult result = adminReactWebSearchScenario.get();
 
-        assertThat(assistantMessages)
+        assertThat(result.assistantMessages())
                 .as("Handler must save an assistant message (even on agent FAILED state)")
                 .isNotEmpty();
     }
@@ -273,35 +253,18 @@ void admin_agentReact_chainsWebSearchAndFetchUrl() {
     @Test
     @Timeout(3 * 60)
     @DisplayName("B3: Agent response saved to DB with correct structure (OpenRouter)")
-    void agentResponse_persistedToDb() {
-        TelegramCommand command = createMessageCommand(
-                ADMIN_CHAT_ID,
-                3,
-                "Answer in one word: is the agent working?"
-        );
+    void agentResponse_persistedToDb() throws Exception {
+        HandledCommandResult result = regularSimpleScenario.get();
 
-        messageHandler.handle(command);
-
-        TelegramUser user = telegramUserRepository.findByTelegramId(ADMIN_CHAT_ID)
-                .orElseThrow();
-
-        ConversationThread thread = threadRepository.findMostRecentActiveThread(user)
-                .orElseThrow();
-
-        List<OpenDaimonMessage> userMessages = messageRepository
-                .findByThreadAndRoleOrderBySequenceNumberAsc(thread, MessageRole.USER);
-        List<OpenDaimonMessage> assistantMessages = messageRepository
-                .findByThreadAndRoleOrderBySequenceNumberAsc(thread, MessageRole.ASSISTANT);
-
-        assertThat(userMessages)
+        assertThat(result.userMessages())
                 .as("User message should be saved")
                 .hasSize(1);
 
-        assertThat(assistantMessages)
+        assertThat(result.assistantMessages())
                 .as("Assistant message should be saved")
                 .hasSize(1);
 
-        assertThat(assistantMessages.getFirst().getContent())
+        assertThat(result.assistantMessages().getFirst().getContent())
                 .as("Assistant content should not be blank")
                 .isNotBlank();
     }
@@ -430,32 +393,18 @@ void admin_agentReact_invokesHttpGet() {
     @Test
     @Timeout(3 * 60)
     @DisplayName("B4: REGULAR agent uses SIMPLE strategy without tools (OpenRouter)")
-    void regular_agentSimple_noTools() {
-        TelegramCommand command = createMessageCommand(
-                REGULAR_CHAT_ID,
-                4,
-                "Tell me a short joke"
-        );
+    void regular_agentSimple_noTools() throws Exception {
+        HandledCommandResult result = regularSimpleScenario.get();
 
-        messageHandler.handle(command);
-
-        TelegramUser user = telegramUserRepository.findByTelegramId(REGULAR_CHAT_ID)
-                .orElseThrow(() -> new IllegalStateException("Telegram user should be created"));
-
-        ConversationThread thread = threadRepository.findMostRecentActiveThread(user)
-                .orElseThrow(() -> new IllegalStateException("Active thread should exist"));
-
-        String assistantReply = latestAssistantReply(thread);
-
-        assertThat(assistantReply)
+        assertThat(result.assistantReply())
                 .as("SIMPLE agent should produce a non-blank response")
                 .isNotBlank();
 
-        assertThat(WEB_SEARCH_CALLED.get())
+        assertThat(result.webSearchCalled())
                 .as("REGULAR (CHAT-only) should NOT invoke web_search")
                 .isFalse();
 
-        assertThat(FETCH_URL_CALLED.get())
+        assertThat(result.fetchUrlCalled())
                 .as("REGULAR (CHAT-only) should NOT invoke fetch_url")
                 .isFalse();
     }
@@ -550,6 +499,47 @@ private io.github.ngirchev.opendaimon.common.model.Attachment loadImageAttachmen
 
     // --- Helpers ---
 
+    private HandledCommandResult runAdminReactWebSearchScenario() {
+        TelegramCommand command = createMessageCommand(
+                ADMIN_CHAT_ID,
+                1,
+                "What is the latest version of Spring Boot released in 2026? Search the internet."
+        );
+        return handleCommand(command, ADMIN_CHAT_ID);
+    }
+
+    private HandledCommandResult runRegularSimpleScenario() {
+        TelegramCommand command = createMessageCommand(
+                REGULAR_CHAT_ID,
+                4,
+                "Tell me a short joke"
+        );
+        return handleCommand(command, REGULAR_CHAT_ID);
+    }
+
+    private HandledCommandResult handleCommand(TelegramCommand command, Long chatId) {
+        messageHandler.handle(command);
+
+        TelegramUser user = telegramUserRepository.findByTelegramId(chatId)
+                .orElseThrow(() -> new IllegalStateException("Telegram user should be created"));
+        ConversationThread thread = threadRepository.findMostRecentActiveThread(user)
+                .orElseThrow(() -> new IllegalStateException("Active thread should exist"));
+        List<OpenDaimonMessage> userMessages = messageRepository
+                .findByThreadAndRoleOrderBySequenceNumberAsc(thread, MessageRole.USER);
+        List<OpenDaimonMessage> assistantMessages = messageRepository
+                .findByThreadAndRoleOrderBySequenceNumberAsc(thread, MessageRole.ASSISTANT);
+        String assistantReply = assistantMessages.isEmpty() ? "" : assistantMessages.getLast().getContent();
+        return new HandledCommandResult(
+                userMessages,
+                assistantMessages,
+                assistantReply,
+                WEB_SEARCH_CALLED.get(),
+                FETCH_URL_CALLED.get(),
+                HTTP_GET_CALLED.get(),
+                TOOL_CALL_COUNT.get()
+        );
+    }
+
     private TelegramCommand createMessageCommand(Long chatId, int messageId, String text) {
         return createMessageCommand(chatId, messageId, text, "en");
     }
@@ -632,6 +622,17 @@ public MockResponse dispatch(RecordedRequest request) {
         return server;
     }
 
+    private record HandledCommandResult(
+            List<OpenDaimonMessage> userMessages,
+            List<OpenDaimonMessage> assistantMessages,
+            String assistantReply,
+            boolean webSearchCalled,
+            boolean fetchUrlCalled,
+            boolean httpGetCalled,
+            int toolCallCount
+    ) {
+    }
+
     @SpringBootConfiguration
     @EnableAutoConfiguration
     static class TestConfig {
diff --git a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/DocRagOpenRouterManualIT.java b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/DocRagOpenRouterManualIT.java
index 4fa4c1b0..b82d1c8a 100644
--- a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/DocRagOpenRouterManualIT.java
+++ b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/DocRagOpenRouterManualIT.java
@@ -83,7 +83,7 @@
  * </pre>
  */
 @Tag("manual")
-@EnabledIfSystemProperty(named = "manual.ollama.e2e", matches = "true")
+@EnabledIfSystemProperty(named = "manual.openrouter.e2e", matches = "true")
 @SpringBootTest(
         classes = OpenRouterSimpleManualTestConfig.class,
         properties = "open-daimon.agent.enabled=false"
diff --git a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/GreekImageVisionOpenRouterManualIT.java b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/GreekImageVisionOpenRouterManualIT.java
index 3ef58213..efc9a1c0 100644
--- a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/GreekImageVisionOpenRouterManualIT.java
+++ b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/GreekImageVisionOpenRouterManualIT.java
@@ -79,7 +79,7 @@
  * </pre>
  */
 @Tag("manual")
-@EnabledIfSystemProperty(named = "manual.ollama.e2e", matches = "true")
+@EnabledIfSystemProperty(named = "manual.openrouter.e2e", matches = "true")
 @SpringBootTest(
         classes = OpenRouterSimpleManualTestConfig.class,
         properties = "open-daimon.agent.enabled=false"
diff --git a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/ImagePdfVisionRagOpenRouterManualIT.java b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/ImagePdfVisionRagOpenRouterManualIT.java
index 90bd9ae2..665ebe49 100644
--- a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/ImagePdfVisionRagOpenRouterManualIT.java
+++ b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/ImagePdfVisionRagOpenRouterManualIT.java
@@ -87,7 +87,7 @@
  * </pre>
  */
 @Tag("manual")
-@EnabledIfSystemProperty(named = "manual.ollama.e2e", matches = "true")
+@EnabledIfSystemProperty(named = "manual.openrouter.e2e", matches = "true")
 @SpringBootTest(
         classes = OpenRouterSimpleManualTestConfig.class,
         properties = "open-daimon.agent.enabled=false"
diff --git a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/ImagesWithTextPdfVisionRagOpenRouterManualIT.java b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/ImagesWithTextPdfVisionRagOpenRouterManualIT.java
index 988cc6c3..b634cbc8 100644
--- a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/ImagesWithTextPdfVisionRagOpenRouterManualIT.java
+++ b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/ImagesWithTextPdfVisionRagOpenRouterManualIT.java
@@ -84,7 +84,7 @@
  * </pre>
  */
 @Tag("manual")
-@EnabledIfSystemProperty(named = "manual.ollama.e2e", matches = "true")
+@EnabledIfSystemProperty(named = "manual.openrouter.e2e", matches = "true")
 @SpringBootTest(
         classes = OpenRouterSimpleManualTestConfig.class,
         properties = "open-daimon.agent.enabled=false"
diff --git a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/ObjectsImageVisionOpenRouterManualIT.java b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/ObjectsImageVisionOpenRouterManualIT.java
index 8c91d0e9..dd50f2b5 100644
--- a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/ObjectsImageVisionOpenRouterManualIT.java
+++ b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/ObjectsImageVisionOpenRouterManualIT.java
@@ -83,7 +83,7 @@
  * </pre>
  */
 @Tag("manual")
-@EnabledIfSystemProperty(named = "manual.ollama.e2e", matches = "true")
+@EnabledIfSystemProperty(named = "manual.openrouter.e2e", matches = "true")
 @SpringBootTest(
         classes = OpenRouterSimpleManualTestConfig.class,
         properties = "open-daimon.agent.enabled=false"
diff --git a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/TextPdfRagOpenRouterManualIT.java b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/TextPdfRagOpenRouterManualIT.java
index d29a7903..d300cc78 100644
--- a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/TextPdfRagOpenRouterManualIT.java
+++ b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/TextPdfRagOpenRouterManualIT.java
@@ -79,7 +79,7 @@
  * </pre>
  */
 @Tag("manual")
-@EnabledIfSystemProperty(named = "manual.ollama.e2e", matches = "true")
+@EnabledIfSystemProperty(named = "manual.openrouter.e2e", matches = "true")
 @SpringBootTest(
         classes = OpenRouterSimpleManualTestConfig.class,
         properties = "open-daimon.agent.enabled=false"
diff --git a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/XlsRagOpenRouterManualIT.java b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/XlsRagOpenRouterManualIT.java
index c03312b1..c787db91 100644
--- a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/XlsRagOpenRouterManualIT.java
+++ b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/XlsRagOpenRouterManualIT.java
@@ -87,7 +87,7 @@
  * </pre>
  */
 @Tag("manual")
-@EnabledIfSystemProperty(named = "manual.ollama.e2e", matches = "true")
+@EnabledIfSystemProperty(named = "manual.openrouter.e2e", matches = "true")
 @SpringBootTest(
         classes = OpenRouterSimpleManualTestConfig.class,
         properties = "open-daimon.agent.enabled=false"
diff --git a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/support/ManualScenarioCache.java b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/support/ManualScenarioCache.java
new file mode 100644
index 00000000..59825669
--- /dev/null
+++ b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/support/ManualScenarioCache.java
@@ -0,0 +1,36 @@
+package io.github.ngirchev.opendaimon.it.manual.support;
+
+/**
+ * Lazily runs an expensive manual scenario once per test instance and reuses
+ * the captured result for assertions in multiple test methods.
+ */
+public final class ManualScenarioCache<T> {
+
+    private final ThrowingSupplier<T> supplier;
+    private T value;
+
+    private ManualScenarioCache(ThrowingSupplier<T> supplier) {
+        this.supplier = supplier;
+    }
+
+    public static <T> ManualScenarioCache<T> of(ThrowingSupplier<T> supplier) {
+        return new ManualScenarioCache<>(supplier);
+    }
+
+    public T get() throws Exception {
+        if (value == null) {
+            value = supplier.get();
+        }
+        return value;
+    }
+
+    public void clear() {
+        value = null;
+    }
+
+    @FunctionalInterface
+    public interface ThrowingSupplier<T> {
+
+        T get() throws Exception;
+    }
+}
diff --git a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/support/ManualTelegramTestSupport.java b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/support/ManualTelegramTestSupport.java
new file mode 100644
index 00000000..dafb21a9
--- /dev/null
+++ b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/support/ManualTelegramTestSupport.java
@@ -0,0 +1,115 @@
+package io.github.ngirchev.opendaimon.it.manual.support;
+
+import io.github.ngirchev.opendaimon.common.model.Attachment;
+import io.github.ngirchev.opendaimon.common.model.AttachmentType;
+import io.github.ngirchev.opendaimon.common.model.ConversationThread;
+import io.github.ngirchev.opendaimon.common.model.MessageRole;
+import io.github.ngirchev.opendaimon.common.model.OpenDaimonMessage;
+import io.github.ngirchev.opendaimon.common.repository.OpenDaimonMessageRepository;
+import io.github.ngirchev.opendaimon.telegram.TelegramBot;
+import io.github.ngirchev.opendaimon.telegram.command.TelegramCommand;
+import io.github.ngirchev.opendaimon.telegram.command.TelegramCommandType;
+import java.io.IOException;
+import java.util.List;
+import org.springframework.core.io.ClassPathResource;
+import org.telegram.telegrambots.meta.api.objects.Chat;
+import org.telegram.telegrambots.meta.api.objects.Message;
+import org.telegram.telegrambots.meta.api.objects.Update;
+import org.telegram.telegrambots.meta.api.objects.User;
+import org.telegram.telegrambots.meta.api.objects.replykeyboard.ReplyKeyboard;
+import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.reset;
+
+public final class ManualTelegramTestSupport {
+
+    private ManualTelegramTestSupport() {
+    }
+
+    public static void stubTelegramBot(TelegramBot telegramBot) throws TelegramApiException {
+        reset(telegramBot);
+        doNothing().when(telegramBot).showTyping(anyLong());
+        doNothing().when(telegramBot).sendMessage(anyLong(), anyString(), any(), any(ReplyKeyboard.class));
+        doNothing().when(telegramBot).sendMessage(anyLong(), anyString(), any());
+        doNothing().when(telegramBot).sendErrorMessage(anyLong(), anyString(), any());
+    }
+
+    public static TelegramCommand createMessageCommand(
+            Long chatId,
+            int messageId,
+            String text,
+            String languageCode,
+            List<Attachment> attachments
+    ) {
+        Update update = new Update();
+
+        User from = new User();
+        from.setId(chatId);
+        from.setUserName("manual-user-" + chatId);
+        from.setFirstName("Manual");
+        from.setLastName("User");
+        from.setLanguageCode(languageCode);
+
+        Message message = new Message();
+        message.setMessageId(messageId);
+        Chat chat = new Chat();
+        chat.setId(chatId);
+        message.setChat(chat);
+        message.setFrom(from);
+        message.setText(text);
+        update.setMessage(message);
+
+        TelegramCommand command = new TelegramCommand(
+                null,
+                chatId,
+                new TelegramCommandType(TelegramCommand.MESSAGE),
+                update,
+                text,
+                false,
+                attachments
+        );
+        command.languageCode(languageCode);
+        return command;
+    }
+
+    public static Attachment loadAttachment(
+            String resourcePath,
+            String contentType,
+            String originalFilename,
+            AttachmentType attachmentType
+    ) throws IOException {
+        ClassPathResource resource = new ClassPathResource(resourcePath);
+        byte[] bytes = resource.getInputStream().readAllBytes();
+        return new Attachment(
+                "manual/" + originalFilename,
+                contentType,
+                originalFilename,
+                bytes.length,
+                attachmentType,
+                bytes
+        );
+    }
+
+    public static List<OpenDaimonMessage> assistantMessages(
+            ConversationThread thread,
+            OpenDaimonMessageRepository messageRepository
+    ) {
+        return messageRepository.findByThreadAndRoleOrderBySequenceNumberAsc(thread, MessageRole.ASSISTANT);
+    }
+
+    public static String latestAssistantReply(
+            ConversationThread thread,
+            OpenDaimonMessageRepository messageRepository
+    ) {
+        List<OpenDaimonMessage> assistantMessages = assistantMessages(thread, messageRepository);
+        assertThat(assistantMessages)
+                .as("Assistant message should be saved")
+                .isNotEmpty();
+        return assistantMessages.getLast().getContent();
+    }
+}
diff --git a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/support/ManualTestPrerequisites.java b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/support/ManualTestPrerequisites.java
new file mode 100644
index 00000000..d56d263b
--- /dev/null
+++ b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/manual/support/ManualTestPrerequisites.java
@@ -0,0 +1,68 @@
+package io.github.ngirchev.opendaimon.it.manual.support;
+
+import io.github.ngirchev.dotenv.DotEnvLoader;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.nio.file.Path;
+import java.time.Duration;
+import java.util.List;
+import org.junit.jupiter.api.Assumptions;
+
+public final class ManualTestPrerequisites {
+
+    private ManualTestPrerequisites() {
+    }
+
+    public static void requireOpenRouterKey() {
+        DotEnvLoader.loadDotEnv(Path.of("../.env"));
+        String openRouterKey = System.getProperty("OPENROUTER_KEY", System.getenv("OPENROUTER_KEY"));
+        Assumptions.assumeTrue(
+                openRouterKey != null && !openRouterKey.isBlank() && !openRouterKey.equals("sk-placeholder"),
+                "Skipping manual test: OPENROUTER_KEY not set in .env or environment"
+        );
+    }
+
+    public static void requireSerperKey() {
+        DotEnvLoader.loadDotEnv(Path.of("../.env"));
+        String serperKey = System.getProperty("SERPER_KEY", System.getenv("SERPER_KEY"));
+        Assumptions.assumeTrue(
+                serperKey != null && !serperKey.isBlank(),
+                "Skipping manual test: SERPER_KEY not set in .env or environment"
+        );
+    }
+
+    public static void requireLocalOllamaWithModels(List<String> requiredModels, Duration timeout) {
+        String baseUrl = resolveOllamaBaseUrl();
+        HttpClient client = HttpClient.newBuilder()
+                .connectTimeout(timeout)
+                .build();
+        HttpRequest request = HttpRequest.newBuilder()
+                .GET()
+                .timeout(timeout)
+                .uri(URI.create(baseUrl + "/api/tags"))
+                .build();
+        try {
+            HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
+            boolean statusOk = response.statusCode() == 200;
+            boolean modelsPresent = requiredModels.stream().allMatch(response.body()::contains);
+            Assumptions.assumeTrue(statusOk && modelsPresent,
+                    "Skipping manual test: Ollama/models unavailable at " + baseUrl + ". Required: " + requiredModels);
+        } catch (Exception ex) {
+            Assumptions.assumeTrue(false,
+                    "Skipping manual test: cannot connect to Ollama at " + baseUrl + ". " + ex.getMessage());
+        }
+    }
+
+    public static String resolveOllamaBaseUrl() {
+        String baseUrl = System.getenv("OLLAMA_BASE_URL");
+        if (baseUrl == null || baseUrl.isBlank()) {
+            baseUrl = "http://localhost:11434";
+        }
+        if (baseUrl.endsWith("/")) {
+            return baseUrl.substring(0, baseUrl.length() - 1);
+        }
+        return baseUrl;
+    }
+}
diff --git a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/telegram/TelegramMockGatewayIT.java b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/telegram/TelegramMockGatewayIT.java
index c99f4b93..36f6a82c 100644
--- a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/telegram/TelegramMockGatewayIT.java
+++ b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/telegram/TelegramMockGatewayIT.java
@@ -58,12 +58,12 @@
 import io.github.ngirchev.opendaimon.telegram.command.TelegramCommandType;
 import io.github.ngirchev.opendaimon.it.TelegramMessageHandlerActionsTestWiring;
 import io.github.ngirchev.opendaimon.telegram.command.handler.impl.MessageTelegramCommandHandler;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerContext;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerEvent;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerFsmFactory;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerState;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.TelegramMessageHandlerActions;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.TelegramMessageSender;
+import io.github.ngirchev.opendaimon.telegram.service.fsm.MessageHandlerContext;
+import io.github.ngirchev.opendaimon.telegram.service.fsm.MessageHandlerEvent;
+import io.github.ngirchev.opendaimon.telegram.service.fsm.MessageHandlerFsmFactory;
+import io.github.ngirchev.opendaimon.telegram.service.fsm.MessageHandlerState;
+import io.github.ngirchev.opendaimon.telegram.service.fsm.TelegramMessageHandlerActions;
+import io.github.ngirchev.opendaimon.telegram.service.TelegramMessageSender;
 import io.github.ngirchev.fsm.impl.extended.ExDomainFsm;
 import io.github.ngirchev.opendaimon.telegram.config.TelegramFlywayConfig;
 import io.github.ngirchev.opendaimon.telegram.config.TelegramJpaConfig;
diff --git a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/telegram/TelegramRealGatewayIT.java b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/telegram/TelegramRealGatewayIT.java
index 9857e8ef..2b6c0cca 100644
--- a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/telegram/TelegramRealGatewayIT.java
+++ b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/telegram/TelegramRealGatewayIT.java
@@ -50,7 +50,7 @@
  *
  * <p>To run the test:
  * <ol>
- *   <li>Ensure .env contains TELEGRAM_TOKEN, TELEGRAM_USERNAME and ADMIN_TELEGRAM_ID</li>
+ *   <li>Ensure .env contains TELEGRAM_TOKEN, TELEGRAM_USERNAME and TEST_TELEGRAM_CHAT_ID</li>
  *   <li>Remove @Disabled from the test or the whole class</li>
  *   <li>Run the test</li>
  * </ol>
@@ -84,7 +84,7 @@ class TelegramRealGatewayIT extends AbstractContainerIT {
         DotEnvLoader.loadDotEnv(Path.of("../.env"));
     }
 
-    @Value("${ADMIN_TELEGRAM_ID}")
+    @Value("${TEST_TELEGRAM_CHAT_ID}")
     private Long adminTelegramId;
 
     @Autowired
diff --git a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/telegram/command/handler/MessageTelegramCommandHandlerIT.java b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/telegram/command/handler/MessageTelegramCommandHandlerIT.java
index f5b3a047..2aa4c92a 100644
--- a/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/telegram/command/handler/MessageTelegramCommandHandlerIT.java
+++ b/opendaimon-app/src/it/java/io/github/ngirchev/opendaimon/it/telegram/command/handler/MessageTelegramCommandHandlerIT.java
@@ -3,7 +3,6 @@
 import io.github.ngirchev.opendaimon.it.ITTestConfiguration;
 import io.github.ngirchev.opendaimon.telegram.service.PersistentKeyboardService;
 import io.github.ngirchev.opendaimon.telegram.service.ReplyImageAttachmentService;
-import io.github.ngirchev.opendaimon.telegram.service.TelegramAgentStreamView;
 import io.github.ngirchev.opendaimon.telegram.service.TelegramChatPacerImpl;
 import io.github.ngirchev.opendaimon.telegram.service.TelegramFileService;
 import io.github.ngirchev.opendaimon.common.service.ChatOwnerLookup;
@@ -49,13 +48,6 @@
 import io.github.ngirchev.opendaimon.telegram.command.TelegramCommandType;
 import io.github.ngirchev.opendaimon.it.TelegramMessageHandlerActionsTestWiring;
 import io.github.ngirchev.opendaimon.telegram.command.handler.impl.MessageTelegramCommandHandler;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerContext;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerEvent;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerFsmFactory;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerState;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.TelegramMessageHandlerActions;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.TelegramMessageSender;
-import io.github.ngirchev.fsm.impl.extended.ExDomainFsm;
 import io.github.ngirchev.opendaimon.telegram.config.TelegramFlywayConfig;
 import io.github.ngirchev.opendaimon.telegram.config.TelegramJpaConfig;
 import io.github.ngirchev.opendaimon.common.storage.config.StorageProperties;
@@ -243,9 +235,12 @@ public TelegramUserService telegramUserService(
         @Bean
         @Primary
         public ObjectProvider<StorageProperties> storagePropertiesProvider() {
-            ObjectProvider<StorageProperties> provider = mock(ObjectProvider.class);
-            when(provider.getIfAvailable()).thenReturn(null);
-            return provider;
+            return new ObjectProvider<>() {
+                @Override
+                public StorageProperties getIfAvailable() {
+                    return null;
+                }
+            };
         }
 
         @Bean
diff --git a/opendaimon-app/src/main/resources/application-mock.yml b/opendaimon-app/src/main/resources/application-mock.yml
index b0f34b11..0ecc22f1 100644
--- a/opendaimon-app/src/main/resources/application-mock.yml
+++ b/opendaimon-app/src/main/resources/application-mock.yml
@@ -15,10 +15,6 @@ open-daimon:
         REGULAR:
           maxConcurrentCalls: 1
           maxWaitDuration: 500ms
-    admin:
-      enabled: ${ADMIN_ENABLED:true}
-      telegram-id: ${ADMIN_TELEGRAM_ID:}
-      rest-email: ${ADMIN_REST_EMAIL:}
     assistant-role: role.content.default
     max-output-tokens: 1000
     max-user-message-tokens: 4000
diff --git a/opendaimon-app/src/main/resources/application.yml b/opendaimon-app/src/main/resources/application.yml
index 10602676..b8fc93c2 100644
--- a/opendaimon-app/src/main/resources/application.yml
+++ b/opendaimon-app/src/main/resources/application.yml
@@ -1,3 +1,8 @@
+# Bundled OpenDaimon runtime keeps its effective configuration explicit in this file.
+# Reference only: external apps that use opendaimon-spring-boot-starter receive low-priority defaults from:
+# opendaimon-spring-boot-starter/src/main/resources/META-INF/opendaimon/opendaimon-defaults.yml
+# This app does not depend on the starter and does not import those defaults, so change runtime values here.
+
 server:
   port: 8080
 
@@ -23,10 +28,6 @@ open-daimon:
         REGULAR:
           maxConcurrentCalls: 1
           maxWaitDuration: 500ms
-    admin:
-      enabled: ${ADMIN_ENABLED:true}
-      telegram-id: ${ADMIN_TELEGRAM_ID:}
-      rest-email: ${ADMIN_REST_EMAIL:}
     assistant-role: role.content.default
     # Hard limit for entire prompt to API (system + history + current). When exceeded — trim/reject and return error.
     max-total-prompt-tokens: 32000
@@ -190,6 +191,7 @@ open-daimon:
                 - stepfun/step-3.5-flash:free
           blacklist:
             exclude-model-ids: []  # add model IDs here to block them permanently
+            exclude-contains: []   # add substrings here to block model families
           ranking:
             enabled: true
             retry-max-attempts: 3
diff --git a/opendaimon-app/src/test/java/io/github/ngirchev/opendaimon/arch/ArchitectureTest.java b/opendaimon-app/src/test/java/io/github/ngirchev/opendaimon/arch/ArchitectureTest.java
new file mode 100644
index 00000000..ade33f2a
--- /dev/null
+++ b/opendaimon-app/src/test/java/io/github/ngirchev/opendaimon/arch/ArchitectureTest.java
@@ -0,0 +1,167 @@
+package io.github.ngirchev.opendaimon.arch;
+
+import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes;
+import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses;
+import static com.tngtech.archunit.library.Architectures.layeredArchitecture;
+import static com.tngtech.archunit.library.dependencies.SlicesRuleDefinition.slices;
+
+import com.tngtech.archunit.core.domain.Dependency;
+import com.tngtech.archunit.core.domain.JavaClass;
+import com.tngtech.archunit.core.importer.ImportOption;
+import com.tngtech.archunit.core.importer.Location;
+import com.tngtech.archunit.junit.AnalyzeClasses;
+import com.tngtech.archunit.junit.ArchTest;
+import com.tngtech.archunit.lang.ArchCondition;
+import com.tngtech.archunit.lang.ArchRule;
+import com.tngtech.archunit.lang.ConditionEvents;
+import com.tngtech.archunit.lang.SimpleConditionEvent;
+import com.tngtech.archunit.library.dependencies.SliceAssignment;
+import com.tngtech.archunit.library.dependencies.SliceIdentifier;
+
+import java.util.Set;
+import java.util.TreeSet;
+
+/**
+ * Executable architectural invariants for the {@code opendaimon-*} library modules.
+ *
+ * <p>Library modules are published to Maven Central and consumed independently, so this
+ * test codifies the module and bean-wiring boundaries from AGENTS.md.
+ */
+@AnalyzeClasses(
+        packages = "io.github.ngirchev.opendaimon",
+        importOptions = {
+                ImportOption.DoNotIncludeTests.class,
+                ArchitectureTest.IncludeOpendaimonOnly.class
+        }
+)
+class ArchitectureTest {
+
+    /**
+     * Admits exploded class files unconditionally and only those JAR entries
+     * whose URI contains "/opendaimon-" (our own multi-module JARs).
+     */
+    public static class IncludeOpendaimonOnly implements ImportOption {
+        @Override
+        public boolean includes(Location location) {
+            if (!location.contains(".jar")) {
+                return true;
+            }
+            return location.contains("/opendaimon-");
+        }
+    }
+
+    private static final SliceAssignment LIBRARY_MODULES = new SliceAssignment() {
+        @Override
+        public SliceIdentifier getIdentifierOf(JavaClass cls) {
+            String pkg = cls.getPackageName();
+            if (pkg.startsWith("io.github.ngirchev.opendaimon.common")) {
+                return SliceIdentifier.of("common");
+            }
+            if (pkg.startsWith("io.github.ngirchev.opendaimon.telegram")) {
+                return SliceIdentifier.of("telegram");
+            }
+            if (pkg.startsWith("io.github.ngirchev.opendaimon.rest")) {
+                return SliceIdentifier.of("rest");
+            }
+            if (pkg.startsWith("io.github.ngirchev.opendaimon.ai.springai")) {
+                return SliceIdentifier.of("spring-ai");
+            }
+            if (pkg.startsWith("io.github.ngirchev.opendaimon.ai.ui")) {
+                return SliceIdentifier.of("ui");
+            }
+            return SliceIdentifier.ignore();
+        }
+
+        @Override
+        public String getDescription() {
+            return "published library modules";
+        }
+    };
+
+    private static final ArchCondition<JavaClass> DEPEND_ON_AT_MOST_ONE_DELIVERY_CHANNEL =
+            new ArchCondition<>("depend on at most one delivery channel module") {
+                @Override
+                public void check(JavaClass item, ConditionEvents events) {
+                    if (item.getPackageName().equals("io.github.ngirchev.opendaimon")) {
+                        return;
+                    }
+                    Set<String> deliveryChannels = new TreeSet<>();
+                    for (Dependency dependency : item.getDirectDependenciesFromSelf()) {
+                        String packageName = dependency.getTargetClass().getPackageName();
+                        if (packageName.startsWith("io.github.ngirchev.opendaimon.telegram")) {
+                            deliveryChannels.add("telegram");
+                        }
+                        if (packageName.startsWith("io.github.ngirchev.opendaimon.rest")) {
+                            deliveryChannels.add("rest");
+                        }
+                    }
+                    if (deliveryChannels.size() > 1) {
+                        events.add(SimpleConditionEvent.violated(
+                                item,
+                                item.getName() + " depends on multiple delivery channels: " + deliveryChannels));
+                    }
+                }
+            };
+
+    @ArchTest
+    static final ArchRule library_modules_use_no_service_or_component_stereotypes =
+            noClasses()
+                    .that().resideInAnyPackage(
+                            "io.github.ngirchev.opendaimon.common..",
+                            "io.github.ngirchev.opendaimon.ai.springai..",
+                            "io.github.ngirchev.opendaimon.telegram..",
+                            "io.github.ngirchev.opendaimon.rest..",
+                            "io.github.ngirchev.opendaimon.ai.ui..")
+                    .should().beAnnotatedWith(org.springframework.stereotype.Service.class)
+                    .orShould().beAnnotatedWith(org.springframework.stereotype.Component.class)
+                    .because("Library modules export beans via @Bean methods in @Configuration classes.");
+
+    @ArchTest
+    static final ArchRule library_modules_use_no_repository_classes =
+            noClasses()
+                    .that().resideInAnyPackage(
+                            "io.github.ngirchev.opendaimon.common..",
+                            "io.github.ngirchev.opendaimon.ai.springai..",
+                            "io.github.ngirchev.opendaimon.telegram..",
+                            "io.github.ngirchev.opendaimon.rest..",
+                            "io.github.ngirchev.opendaimon.ai.ui..")
+                    .and().areNotInterfaces()
+                    .should().beAnnotatedWith(org.springframework.stereotype.Repository.class)
+                    .because("@Repository is only allowed on Spring Data repository interfaces.");
+
+    @ArchTest
+    static final ArchRule library_modules_have_no_cyclic_dependencies =
+            slices().assignedFrom(LIBRARY_MODULES)
+                    .should().beFreeOfCycles()
+                    .because("Cycles between published library modules break independent consumption.");
+
+    @ArchTest
+    static final ArchRule telegram_module_does_not_depend_on_rest_module =
+            noClasses()
+                    .that().resideInAPackage("io.github.ngirchev.opendaimon.telegram..")
+                    .should().dependOnClassesThat().resideInAPackage("io.github.ngirchev.opendaimon.rest..")
+                    .because("Delivery channels must stay independently consumable.");
+
+    @ArchTest
+    static final ArchRule rest_module_does_not_depend_on_telegram_module =
+            noClasses()
+                    .that().resideInAPackage("io.github.ngirchev.opendaimon.rest..")
+                    .should().dependOnClassesThat().resideInAPackage("io.github.ngirchev.opendaimon.telegram..")
+                    .because("Delivery channels must stay independently consumable.");
+
+    @ArchTest
+    static final ArchRule only_app_depends_on_multiple_delivery_channel_modules =
+            classes()
+                    .that().resideInAPackage("io.github.ngirchev.opendaimon..")
+                    .should(DEPEND_ON_AT_MOST_ONE_DELIVERY_CHANNEL)
+                    .because("Only the runtime app may compose multiple delivery channels.");
+
+    @ArchTest
+    static final ArchRule repositories_are_accessed_only_from_service_or_config =
+            layeredArchitecture().consideringAllDependencies()
+                    .layer("Repository").definedBy("io.github.ngirchev.opendaimon..repository..")
+                    .layer("Service").definedBy("io.github.ngirchev.opendaimon..service..")
+                    .layer("Config").definedBy("io.github.ngirchev.opendaimon..config..")
+                    .whereLayer("Repository").mayOnlyBeAccessedByLayers("Service", "Config")
+                    .because("Repository access must stay behind service APIs and explicit @Bean configuration.");
+}
diff --git a/opendaimon-app/src/test/java/io/github/ngirchev/opendaimon/it/springai/SpringAIGatewayStreamingRealContextIT.java b/opendaimon-app/src/test/java/io/github/ngirchev/opendaimon/it/springai/SpringAIGatewayStreamingRealContextIT.java
index e8f0c6f2..67b6985c 100644
--- a/opendaimon-app/src/test/java/io/github/ngirchev/opendaimon/it/springai/SpringAIGatewayStreamingRealContextIT.java
+++ b/opendaimon-app/src/test/java/io/github/ngirchev/opendaimon/it/springai/SpringAIGatewayStreamingRealContextIT.java
@@ -3,15 +3,21 @@
 import lombok.extern.slf4j.Slf4j;
 import okhttp3.mockwebserver.MockResponse;
 import okhttp3.mockwebserver.MockWebServer;
+import org.springframework.ai.model.tool.ToolCallingManager;
+import org.springframework.ai.openai.OpenAiChatModel;
+import org.springframework.ai.openai.OpenAiChatOptions;
+import org.springframework.ai.openai.api.OpenAiApi;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
+import org.springframework.context.annotation.Bean;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.SpringBootConfiguration;
 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.context.annotation.Import;
 import org.springframework.http.MediaType;
+import org.springframework.test.context.ActiveProfiles;
 import org.springframework.test.context.DynamicPropertyRegistry;
 import org.springframework.test.context.DynamicPropertySource;
 import org.springframework.test.context.TestPropertySource;
@@ -54,6 +60,7 @@
         CoreJpaConfig.class,
         SpringAIFlywayConfig.class
 })
+@ActiveProfiles("integration-test")
 @TestPropertySource(properties = {
         "spring.autoconfigure.exclude=org.springframework.ai.model.chat.memory.autoconfigure.ChatMemoryAutoConfiguration",
         "spring.ai.ollama.base-url=http://127.0.0.1:0",
@@ -101,8 +108,7 @@ class SpringAIGatewayStreamingRealContextIT extends AbstractContainerIT {
 
     @BeforeAll
     static void startMockServer() throws IOException {
-        mockWebServer = new MockWebServer();
-        mockWebServer.start();
+        ensureMockServerStarted();
     }
 
     @AfterAll
@@ -114,10 +120,26 @@ static void shutdownMockServer() throws IOException {
 
     @DynamicPropertySource
     static void setOpenAiBaseUrl(DynamicPropertyRegistry registry) {
-        registry.add("spring.ai.openai.base-url", () -> mockWebServer.url("/").toString());
+        registry.add("spring.ai.openai.base-url", SpringAIGatewayStreamingRealContextIT::mockServerBaseUrl);
         registry.add("spring.ai.openai.api-key", () -> "test");
     }
 
+    private static synchronized void ensureMockServerStarted() throws IOException {
+        if (mockWebServer == null) {
+            mockWebServer = new MockWebServer();
+            mockWebServer.start();
+        }
+    }
+
+    private static String mockServerBaseUrl() {
+        try {
+            ensureMockServerStarted();
+        } catch (IOException e) {
+            throw new IllegalStateException("Failed to start OpenAI mock server", e);
+        }
+        return mockWebServer.url("/").toString();
+    }
+
     @Autowired
     private SpringAIGateway springAIGateway;
 
@@ -217,5 +239,21 @@ private Map<String, Object> createBodyWithMaxPrice() {
             "org.springframework.ai.model.openai.autoconfigure.OpenAiModerationAutoConfiguration"
     })
     static class TestConfig {
+        @Bean
+        OpenAiChatModel openAiChatModel(ToolCallingManager toolCallingManager) {
+            OpenAiApi openAiApi = OpenAiApi.builder()
+                    .baseUrl(mockServerBaseUrl())
+                    .apiKey("test")
+                    .completionsPath("/v1/chat/completions")
+                    .build();
+
+            return OpenAiChatModel.builder()
+                    .openAiApi(openAiApi)
+                    .defaultOptions(OpenAiChatOptions.builder()
+                            .model("openrouter/auto")
+                            .build())
+                    .toolCallingManager(toolCallingManager)
+                    .build();
+        }
     }
 }
diff --git a/opendaimon-common/pom.xml b/opendaimon-common/pom.xml
index 5f874553..7d474768 100644
--- a/opendaimon-common/pom.xml
+++ b/opendaimon-common/pom.xml
@@ -30,49 +30,79 @@
     </properties>
 
     <dependencies>
+        <!-- FSM (finite state machine) for document processing pipeline -->
         <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot</artifactId>
+            <groupId>io.github.ngirchev</groupId>
+            <artifactId>fsm</artifactId>
         </dependency>
+
+        <!-- Spring Framework leaves (declare what you use; come transitively via Boot starters) -->
         <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-autoconfigure</artifactId>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-core</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-beans</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-context</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-tx</artifactId>
         </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-web</artifactId>
         </dependency>
-
         <!-- WebClient -->
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-webflux</artifactId>
+        </dependency>
+        <!-- Reactor (Mono / Flux for streaming AI responses) -->
+        <dependency>
+            <groupId>io.projectreactor</groupId>
+            <artifactId>reactor-core</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.reactivestreams</groupId>
+            <artifactId>reactive-streams</artifactId>
+        </dependency>
+        <!-- Spring Boot core -->
         <dependency>
             <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-webflux</artifactId>
+            <artifactId>spring-boot</artifactId>
         </dependency>
-
-        <!-- AOP (aspects for metrics/retry wrappers) -->
         <dependency>
             <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-aop</artifactId>
+            <artifactId>spring-boot-autoconfigure</artifactId>
         </dependency>
 
+        <!-- Spring Data -->
+        <dependency>
+            <groupId>org.springframework.data</groupId>
+            <artifactId>spring-data-commons</artifactId>
+        </dependency>
         <dependency>
             <groupId>org.springframework.data</groupId>
             <artifactId>spring-data-jpa</artifactId>
         </dependency>
+
+        <!-- Spring AI -->
         <dependency>
             <groupId>org.springframework.ai</groupId>
             <artifactId>spring-ai-model</artifactId>
         </dependency>
+
+        <!-- Validation -->
         <dependency>
             <groupId>jakarta.validation</groupId>
             <artifactId>jakarta.validation-api</artifactId>
         </dependency>
-        <dependency>
-            <groupId>org.hibernate.validator</groupId>
-            <artifactId>hibernate-validator</artifactId>
-        </dependency>
-
-        <!-- PostgreSQL -->
+        <!-- JPA / Persistence -->
         <dependency>
             <groupId>jakarta.persistence</groupId>
             <artifactId>jakarta.persistence-api</artifactId>
@@ -81,79 +111,123 @@
             <groupId>org.hibernate.orm</groupId>
             <artifactId>hibernate-core</artifactId>
         </dependency>
+        <!-- Flyway core for module-scoped migrations -->
         <dependency>
-            <groupId>org.postgresql</groupId>
-            <artifactId>postgresql</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>jakarta.xml.bind</groupId>
-            <artifactId>jakarta.xml.bind-api</artifactId>
+            <groupId>org.flywaydb</groupId>
+            <artifactId>flyway-core</artifactId>
         </dependency>
-
         <dependency>
             <groupId>org.flywaydb</groupId>
-            <artifactId>flyway-core</artifactId>
+            <artifactId>flyway-database-postgresql</artifactId>
+            <scope>runtime</scope>
         </dependency>
 
-        <!-- Logging API (implementation provided by client/app) -->
+        <!-- Logging API (impl provided by client/app) -->
         <dependency>
             <groupId>org.slf4j</groupId>
             <artifactId>slf4j-api</artifactId>
         </dependency>
+
+        <!-- Lombok: compile-only annotation processor -->
         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>
+            <scope>provided</scope>
             <optional>true</optional>
         </dependency>
+
+        <!-- JetBrains @Nullable / @NotNull annotations -->
         <dependency>
-            <groupId>io.vavr</groupId>
-            <artifactId>vavr</artifactId>
+            <groupId>org.jetbrains</groupId>
+            <artifactId>annotations</artifactId>
         </dependency>
 
-        <!-- FSM (finite state machine) for document processing pipeline -->
+        <!-- Jakarta annotations (@PostConstruct, @PreDestroy) -->
         <dependency>
-            <groupId>io.github.ngirchev</groupId>
-            <artifactId>fsm</artifactId>
+            <groupId>jakarta.annotation</groupId>
+            <artifactId>jakarta.annotation-api</artifactId>
         </dependency>
 
+        <!-- Jackson -->
         <dependency>
-            <groupId>io.micrometer</groupId>
-            <artifactId>micrometer-registry-prometheus</artifactId>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+        </dependency>
+
+        <!-- Vavr functional patterns -->
+        <dependency>
+            <groupId>io.vavr</groupId>
+            <artifactId>vavr</artifactId>
         </dependency>
 
-        <!-- Caffeine -->
+        <!-- Metrics -->
+        <dependency>
+            <groupId>io.micrometer</groupId>
+            <artifactId>micrometer-core</artifactId>
+        </dependency>
+        <!-- Caffeine cache -->
         <dependency>
             <groupId>com.github.ben-manes.caffeine</groupId>
             <artifactId>caffeine</artifactId>
-            <version>${caffeine.version}</version>
         </dependency>
 
-        <!-- MinIO (optional - for file storage) -->
+        <!-- MinIO (optional, for file storage) -->
         <dependency>
             <groupId>io.minio</groupId>
             <artifactId>minio</artifactId>
-            <version>${minio.version}</version>
             <optional>true</optional>
         </dependency>
 
         <!-- Resilience4j -->
-        <dependency>
-            <groupId>io.github.resilience4j</groupId>
-            <artifactId>resilience4j-spring-boot2</artifactId>
-            <version>${resilience4j.version}</version>
-        </dependency>
         <dependency>
             <groupId>io.github.resilience4j</groupId>
             <artifactId>resilience4j-bulkhead</artifactId>
-            <version>${resilience4j.version}</version>
         </dependency>
 
         <!-- Test -->
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-test</artifactId>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-test</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.hibernate.validator</groupId>
+            <artifactId>hibernate-validator</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.tngtech.archunit</groupId>
+            <artifactId>archunit</artifactId>
+            <version>${archunit.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.tngtech.archunit</groupId>
+            <artifactId>archunit-junit5-api</artifactId>
+            <version>${archunit.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.tngtech.archunit</groupId>
+            <artifactId>archunit-junit5-engine</artifactId>
+            <version>${archunit.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>org.mockito</groupId>
             <artifactId>mockito-junit-jupiter</artifactId>
@@ -186,6 +260,33 @@
                     </excludes>
                 </configuration>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-dependency-plugin</artifactId>
+                <configuration>
+                    <ignoredUnusedDeclaredDependencies>
+                        <!-- ArchUnit JUnit engine is discovered by JUnit Platform at runtime;
+                             no test class imports it directly. -->
+                        <ignored>com.tngtech.archunit:archunit-junit5-engine</ignored>
+                        <!-- Flyway loads database support modules through runtime service discovery. -->
+                        <ignored>org.flywaydb:flyway-database-postgresql</ignored>
+                    </ignoredUnusedDeclaredDependencies>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-enforcer-plugin</artifactId>
+                <configuration>
+                    <rules>
+                        <bannedDependencies>
+                            <searchTransitive>true</searchTransitive>
+                            <excludes>
+                                <exclude>org.springframework.boot:spring-boot-starter*</exclude>
+                            </excludes>
+                        </bannedDependencies>
+                    </rules>
+                </configuration>
+            </plugin>
         </plugins>
     </build>
-</project>
\ No newline at end of file
+</project>
diff --git a/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/agent/persistence/AgentExecutionRepository.java b/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/agent/persistence/AgentExecutionRepository.java
index 13aa6d1e..d09ea063 100644
--- a/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/agent/persistence/AgentExecutionRepository.java
+++ b/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/agent/persistence/AgentExecutionRepository.java
@@ -1,14 +1,12 @@
 package io.github.ngirchev.opendaimon.common.agent.persistence;
 
 import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
 
 import java.util.List;
 
 /**
  * Repository for agent execution persistence.
  */
-@Repository
 public interface AgentExecutionRepository extends JpaRepository<AgentExecutionEntity, Long> {
 
     List<AgentExecutionEntity> findByConversationIdOrderByStartedAtDesc(String conversationId);
diff --git a/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/config/CoreAutoConfig.java b/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/config/CoreAutoConfig.java
index c20d23ec..dbae688d 100644
--- a/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/config/CoreAutoConfig.java
+++ b/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/config/CoreAutoConfig.java
@@ -1,6 +1,7 @@
 package io.github.ngirchev.opendaimon.common.config;
 
 import io.micrometer.core.instrument.MeterRegistry;
+import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
 import org.springframework.beans.factory.ObjectProvider;
 import org.springframework.boot.autoconfigure.AutoConfiguration;
 import org.springframework.boot.autoconfigure.AutoConfigureAfter;
@@ -276,6 +277,12 @@ public SummarizationService summarizationService(
         );
     }
 
+    @Bean
+    @ConditionalOnMissingBean
+    public MeterRegistry meterRegistry() {
+        return new SimpleMeterRegistry();
+    }
+
     @Bean
     @ConditionalOnMissingBean
     public OpenDaimonMeterRegistry openDaimonMeterRegistry(MeterRegistry meterRegistry) {
diff --git a/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/config/CoreCommonProperties.java b/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/config/CoreCommonProperties.java
index 1f5e2f08..90b94125 100644
--- a/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/config/CoreCommonProperties.java
+++ b/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/config/CoreCommonProperties.java
@@ -68,13 +68,6 @@ public boolean isMaxReasoningTokensValid() {
     @NestedConfigurationProperty
     private SummarizationProperties summarization = new SummarizationProperties();
 
-    /**
-     * Admin initialization at application startup.
-     */
-    @Valid
-    @NestedConfigurationProperty
-    private AdminProperties admin = new AdminProperties();
-
     /**
      * AI command routing by user priority. YAML uses {@code ADMIN} / {@code VIP} / {@code REGULAR} keys
      * (same style as {@code open-daimon.telegram.access}); Java fields are {@code admin}, {@code vip}, {@code regular}.
@@ -135,30 +128,6 @@ public static class SummarizationProperties {
         private String prompt;
     }
 
-    /**
-     * Admin configuration properties.
-     */
-    @Getter
-    @Setter
-    @Validated
-    public static class AdminProperties {
-
-        /**
-         * Whether to run admin initialization.
-         */
-        private Boolean enabled = false;
-
-        /**
-         * Admin Telegram ID (optional).
-         */
-        private Long telegramId;
-
-        /**
-         * Admin REST email (optional).
-         */
-        private String restEmail;
-    }
-
     /**
      * Nested {@code ADMIN} / {@code VIP} / {@code REGULAR} blocks under {@code open-daimon.common.chat-routing}.
      */
@@ -214,4 +183,4 @@ public static class PriorityChatRoutingProperties {
         @NotNull(message = "optionalCapabilities is required")
         private List<ModelCapabilities> optionalCapabilities;
     }
-}
\ No newline at end of file
+}
diff --git a/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/repository/AssistantRoleRepository.java b/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/repository/AssistantRoleRepository.java
index 3128efb0..d979d314 100644
--- a/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/repository/AssistantRoleRepository.java
+++ b/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/repository/AssistantRoleRepository.java
@@ -4,7 +4,6 @@
 import org.springframework.data.jpa.repository.Modifying;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.query.Param;
-import org.springframework.stereotype.Repository;
 import io.github.ngirchev.opendaimon.common.model.AssistantRole;
 import io.github.ngirchev.opendaimon.common.model.User;
 
@@ -12,7 +11,6 @@
 import java.util.List;
 import java.util.Optional;
 
-@Repository
 public interface AssistantRoleRepository extends JpaRepository<AssistantRole, Long> {
     
     /**
diff --git a/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/repository/BugreportRepository.java b/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/repository/BugreportRepository.java
index 6d39eb0c..40589c20 100644
--- a/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/repository/BugreportRepository.java
+++ b/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/repository/BugreportRepository.java
@@ -1,14 +1,12 @@
 package io.github.ngirchev.opendaimon.common.repository;
 
 import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
 import io.github.ngirchev.opendaimon.common.model.Bugreport;
 import io.github.ngirchev.opendaimon.common.model.BugreportType;
 import io.github.ngirchev.opendaimon.common.model.User;
 
 import java.util.List;
 
-@Repository
 public interface BugreportRepository extends JpaRepository<Bugreport, Long> {
     
     List<Bugreport> findByUserOrderByCreatedAtDesc(User user);
diff --git a/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/repository/ConversationThreadRepository.java b/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/repository/ConversationThreadRepository.java
index a7ff5106..51dc70f7 100644
--- a/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/repository/ConversationThreadRepository.java
+++ b/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/repository/ConversationThreadRepository.java
@@ -3,7 +3,6 @@
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.query.Param;
-import org.springframework.stereotype.Repository;
 import io.github.ngirchev.opendaimon.common.model.ConversationThread;
 import io.github.ngirchev.opendaimon.common.model.ThreadScopeKind;
 import io.github.ngirchev.opendaimon.common.model.User;
@@ -12,7 +11,6 @@
 import java.util.List;
 import java.util.Optional;
 
-@Repository
 public interface ConversationThreadRepository extends JpaRepository<ConversationThread, Long> {
 
     /**
diff --git a/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/repository/OpenDaimonMessageRepository.java b/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/repository/OpenDaimonMessageRepository.java
index 66642bfe..cb181dac 100644
--- a/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/repository/OpenDaimonMessageRepository.java
+++ b/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/repository/OpenDaimonMessageRepository.java
@@ -3,7 +3,6 @@
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.query.Param;
-import org.springframework.stereotype.Repository;
 import io.github.ngirchev.opendaimon.common.model.ConversationThread;
 import io.github.ngirchev.opendaimon.common.model.OpenDaimonMessage;
 import io.github.ngirchev.opendaimon.common.model.MessageRole;
@@ -16,7 +15,6 @@
  * Repository for dialog messages.
  * Replaces UserRequestRepository and ServiceResponseRepository.
  */
-@Repository
 public interface OpenDaimonMessageRepository extends JpaRepository<OpenDaimonMessage, Long> {
     
     /**
diff --git a/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/repository/UserRecentModelRepository.java b/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/repository/UserRecentModelRepository.java
index 090b89e8..bbc9b682 100644
--- a/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/repository/UserRecentModelRepository.java
+++ b/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/repository/UserRecentModelRepository.java
@@ -5,12 +5,10 @@
 import org.springframework.data.jpa.repository.Modifying;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.query.Param;
-import org.springframework.stereotype.Repository;
 
 import java.util.List;
 import java.util.Optional;
 
-@Repository
 public interface UserRecentModelRepository extends JpaRepository<UserRecentModel, Long> {
 
     /**
diff --git a/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/repository/UserRepository.java b/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/repository/UserRepository.java
index 2d847849..d678b415 100644
--- a/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/repository/UserRepository.java
+++ b/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/repository/UserRepository.java
@@ -1,14 +1,12 @@
 package io.github.ngirchev.opendaimon.common.repository;
 
 import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
 import io.github.ngirchev.opendaimon.common.model.User;
 
 /**
  * Repository for base user table.
  * Supports polymorphic queries for TelegramUser and RestUser.
  */
-@Repository
 public interface UserRepository extends JpaRepository<User, Long> {
 }
 
diff --git a/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/service/ConversationThreadService.java b/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/service/ConversationThreadService.java
index 2fb62b73..83e2dc80 100644
--- a/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/service/ConversationThreadService.java
+++ b/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/service/ConversationThreadService.java
@@ -186,9 +186,29 @@ public Optional<ConversationThread> findCurrentThread(ThreadScopeKind scopeKind,
             .filter(this::isThreadStillActive);
     }
 
+    /**
+     * Returns all threads for a scope, newest activity first.
+     */
+    @Transactional(readOnly = true)
+    public List<ConversationThread> findThreads(ThreadScopeKind scopeKind, Long scopeId) {
+        validateScope(scopeKind, scopeId);
+        return threadRepository.findByScopeKindAndScopeIdOrderByLastActivityAtDesc(scopeKind, scopeId);
+    }
+
+    /**
+     * Closes the current active thread for a scope if one exists.
+     */
+    public boolean closeCurrentThread(ThreadScopeKind scopeKind, Long scopeId) {
+        validateScope(scopeKind, scopeId);
+        Optional<ConversationThread> currentThread = threadRepository.findMostRecentActiveThread(scopeKind, scopeId);
+        currentThread.ifPresent(this::closeThread);
+        return currentThread.isPresent();
+    }
+
     /**
      * Finds thread by key.
      */
+    @Transactional(readOnly = true)
     public Optional<ConversationThread> findByThreadKey(String threadKey) {
         return threadRepository.findByThreadKey(threadKey);
     }
diff --git a/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/service/OpenDaimonMessageService.java b/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/service/OpenDaimonMessageService.java
index f45645e1..8a771e12 100644
--- a/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/service/OpenDaimonMessageService.java
+++ b/opendaimon-common/src/main/java/io/github/ngirchev/opendaimon/common/service/OpenDaimonMessageService.java
@@ -398,6 +398,19 @@ public List<String> findRagDocumentIds(ConversationThread thread) {
         return result;
     }
 
+    @Transactional(readOnly = true)
+    public List<OpenDaimonMessage> findByThreadOrderBySequenceNumberAsc(ConversationThread thread) {
+        return messageRepository.findByThreadOrderBySequenceNumberAsc(thread);
+    }
+
+    @Transactional(readOnly = true)
+    public List<OpenDaimonMessage> findByThreadAndSequenceNumberGreaterThanOrderBySequenceNumberAsc(
+            ConversationThread thread,
+            Integer minSequenceNumber) {
+        return messageRepository.findByThreadAndSequenceNumberGreaterThanOrderBySequenceNumberAsc(
+                thread, minSequenceNumber);
+    }
+
     /**
      * Stores RAG documentIds and filenames in the metadata of a USER message.
      *
diff --git a/opendaimon-common/src/test/java/io/github/ngirchev/opendaimon/bulkhead/config/BulkHeadPropertiesTest.java b/opendaimon-common/src/test/java/io/github/ngirchev/opendaimon/bulkhead/config/BulkHeadPropertiesTest.java
index a0207155..6b5c3f61 100644
--- a/opendaimon-common/src/test/java/io/github/ngirchev/opendaimon/bulkhead/config/BulkHeadPropertiesTest.java
+++ b/opendaimon-common/src/test/java/io/github/ngirchev/opendaimon/bulkhead/config/BulkHeadPropertiesTest.java
@@ -1,5 +1,9 @@
 package io.github.ngirchev.opendaimon.bulkhead.config;
 
+import jakarta.validation.Validation;
+import jakarta.validation.ValidatorFactory;
+import org.hibernate.validator.HibernateValidator;
+import org.hibernate.validator.messageinterpolation.ParameterMessageInterpolator;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
@@ -35,6 +39,16 @@ static class TestConfiguration {
     @Autowired
     private BulkHeadProperties properties;
 
+    @Test
+    void testValidationProvider_ShouldBeAvailableForConfigurationPropertiesBinding() {
+        try (ValidatorFactory validatorFactory = Validation.byProvider(HibernateValidator.class)
+                .configure()
+                .messageInterpolator(new ParameterMessageInterpolator())
+                .buildValidatorFactory()) {
+            assertNotNull(validatorFactory.getValidator(), "Validation provider must create a validator");
+        }
+    }
+
     @Test
     void testBulkHeadProperties_ShouldLoadAllInstances() {
         // Assert
diff --git a/opendaimon-common/src/test/java/io/github/ngirchev/opendaimon/common/arch/CommonArchitectureTest.java b/opendaimon-common/src/test/java/io/github/ngirchev/opendaimon/common/arch/CommonArchitectureTest.java
new file mode 100644
index 00000000..68e6e3f0
--- /dev/null
+++ b/opendaimon-common/src/test/java/io/github/ngirchev/opendaimon/common/arch/CommonArchitectureTest.java
@@ -0,0 +1,195 @@
+package io.github.ngirchev.opendaimon.common.arch;
+
+import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes;
+import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.methods;
+import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses;
+import static com.tngtech.archunit.library.dependencies.SlicesRuleDefinition.slices;
+
+import com.tngtech.archunit.core.domain.JavaClass;
+import com.tngtech.archunit.core.importer.ImportOption;
+import com.tngtech.archunit.junit.AnalyzeClasses;
+import com.tngtech.archunit.junit.ArchTest;
+import com.tngtech.archunit.lang.ArchCondition;
+import com.tngtech.archunit.lang.ArchRule;
+import com.tngtech.archunit.lang.ConditionEvents;
+import com.tngtech.archunit.lang.SimpleConditionEvent;
+import com.tngtech.archunit.library.dependencies.SliceAssignment;
+import com.tngtech.archunit.library.dependencies.SliceIdentifier;
+import org.springframework.boot.autoconfigure.AutoConfiguration;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.stereotype.Controller;
+import org.springframework.stereotype.Component;
+import org.springframework.stereotype.Repository;
+import org.springframework.stereotype.Service;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.ControllerAdvice;
+import org.springframework.web.bind.annotation.RestController;
+
+@AnalyzeClasses(
+        packages = {
+                "io.github.ngirchev.opendaimon.common",
+                "io.github.ngirchev.opendaimon.bulkhead"
+        },
+        importOptions = {
+                ImportOption.DoNotIncludeTests.class,
+                ImportOption.DoNotIncludeJars.class
+        }
+)
+class CommonArchitectureTest {
+
+    private static final String[] COMMON_MODULE_PACKAGES = {
+            "io.github.ngirchev.opendaimon.common..",
+            "io.github.ngirchev.opendaimon.bulkhead.."
+    };
+
+    private static final String[] DOWNSTREAM_MODULE_PACKAGES = {
+            "io.github.ngirchev.opendaimon.ai.springai..",
+            "io.github.ngirchev.opendaimon.ai.ui..",
+            "io.github.ngirchev.opendaimon.telegram..",
+            "io.github.ngirchev.opendaimon.rest.."
+    };
+
+    private static final String[] COMMON_CONFIG_PACKAGES = {
+            "io.github.ngirchev.opendaimon.common.config..",
+            "io.github.ngirchev.opendaimon.common.storage.config..",
+            "io.github.ngirchev.opendaimon.bulkhead.config.."
+    };
+
+    private static final ArchCondition<JavaClass> HAVE_COMMON_CONFIGURATION_PREFIX =
+            new ArchCondition<>("have an open-daimon.common configuration prefix") {
+                @Override
+                public void check(JavaClass item, ConditionEvents events) {
+                    ConfigurationProperties annotation = item.getAnnotationOfType(ConfigurationProperties.class);
+                    String prefix = annotation.prefix().isBlank() ? annotation.value() : annotation.prefix();
+                    if (!prefix.startsWith("open-daimon.common")) {
+                        events.add(SimpleConditionEvent.violated(
+                                item,
+                                item.getName() + " uses configuration prefix '" + prefix + "'"));
+                    }
+                }
+            };
+
+    private static final SliceAssignment COMMON_RUNTIME_SLICES = new SliceAssignment() {
+        @Override
+        public SliceIdentifier getIdentifierOf(JavaClass javaClass) {
+            String packageName = javaClass.getPackageName();
+            if (packageName.startsWith("io.github.ngirchev.opendaimon.bulkhead")) {
+                return SliceIdentifier.of("bulkhead");
+            }
+            if (packageName.startsWith("io.github.ngirchev.opendaimon.common.agent")) {
+                return SliceIdentifier.of("agent");
+            }
+            if (packageName.startsWith("io.github.ngirchev.opendaimon.common.ai")) {
+                return SliceIdentifier.of("ai");
+            }
+            if (packageName.startsWith("io.github.ngirchev.opendaimon.common.command")) {
+                return SliceIdentifier.of("command");
+            }
+            if (packageName.startsWith("io.github.ngirchev.opendaimon.common.meter")) {
+                return SliceIdentifier.of("meter");
+            }
+            if (packageName.startsWith("io.github.ngirchev.opendaimon.common.model")) {
+                return SliceIdentifier.of("model");
+            }
+            if (packageName.startsWith("io.github.ngirchev.opendaimon.common.repository")) {
+                return SliceIdentifier.of("repository");
+            }
+            if (packageName.startsWith("io.github.ngirchev.opendaimon.common.service")) {
+                return SliceIdentifier.of("service");
+            }
+            if (packageName.startsWith("io.github.ngirchev.opendaimon.common.storage")) {
+                return SliceIdentifier.of("storage");
+            }
+            return SliceIdentifier.ignore();
+        }
+
+        @Override
+        public String getDescription() {
+            return "common runtime slices";
+        }
+    };
+
+    @ArchTest
+    static final ArchRule common_module_uses_no_service_or_component_stereotypes =
+            noClasses()
+                    .that().resideInAnyPackage(COMMON_MODULE_PACKAGES)
+                    .should().beAnnotatedWith(Service.class)
+                    .orShould().beAnnotatedWith(Component.class)
+                    .because("common exports Spring beans through explicit auto-configuration.");
+
+    @ArchTest
+    static final ArchRule common_module_uses_no_repository_classes =
+            noClasses()
+                    .that().resideInAnyPackage(COMMON_MODULE_PACKAGES)
+                    .and().areNotInterfaces()
+                    .should().beAnnotatedWith(Repository.class)
+                    .because("@Repository is only allowed on Spring Data repository interfaces.");
+
+    @ArchTest
+    static final ArchRule common_module_defines_no_delivery_controllers =
+            noClasses()
+                    .that().resideInAnyPackage(COMMON_MODULE_PACKAGES)
+                    .should().beAnnotatedWith(Controller.class)
+                    .orShould().beAnnotatedWith(RestController.class)
+                    .orShould().beAnnotatedWith(ControllerAdvice.class)
+                    .because("common is a base library, not a delivery module.");
+
+    @ArchTest
+    static final ArchRule common_module_does_not_depend_on_downstream_modules =
+            noClasses()
+                    .that().resideInAnyPackage(COMMON_MODULE_PACKAGES)
+                    .should().dependOnClassesThat().resideInAnyPackage(DOWNSTREAM_MODULE_PACKAGES)
+                    .because("opendaimon-common is the base library and must not depend on delivery or AI modules.");
+
+    @ArchTest
+    static final ArchRule common_runtime_slices_have_no_cycles =
+            slices().assignedFrom(COMMON_RUNTIME_SLICES)
+                    .should().beFreeOfCycles()
+                    .because("common package slices should stay independently understandable and reusable.");
+
+    @ArchTest
+    static final ArchRule repositories_are_interfaces =
+            classes()
+                    .that().resideInAnyPackage(COMMON_MODULE_PACKAGES)
+                    .and().haveSimpleNameEndingWith("Repository")
+                    .should().beInterfaces()
+                    .because("common repositories are Spring Data interfaces, not concrete infrastructure classes.");
+
+    @ArchTest
+    static final ArchRule bean_methods_are_declared_only_in_config_packages =
+            methods()
+                    .that().areAnnotatedWith(Bean.class)
+                    .should().beDeclaredInClassesThat().resideInAnyPackage(COMMON_CONFIG_PACKAGES)
+                    .because("common beans must be exposed through explicit configuration classes.");
+
+    @ArchTest
+    static final ArchRule configuration_classes_are_declared_only_in_config_packages =
+            classes()
+                    .that().areAnnotatedWith(AutoConfiguration.class)
+                    .or().areAnnotatedWith(Configuration.class)
+                    .should().resideInAnyPackage(COMMON_CONFIG_PACKAGES)
+                    .because("Spring configuration belongs in config packages.");
+
+    @ArchTest
+    static final ArchRule configuration_properties_follow_common_conventions =
+            classes()
+                    .that().areAnnotatedWith(ConfigurationProperties.class)
+                    .should().resideInAnyPackage(COMMON_CONFIG_PACKAGES)
+                    .andShould().haveSimpleNameEndingWith("Properties")
+                    .andShould().beAnnotatedWith(Validated.class)
+                    .andShould(HAVE_COMMON_CONFIGURATION_PREFIX)
+                    .because("common configuration properties must stay validated and under open-daimon.common.");
+
+    @ArchTest
+    static final ArchRule repositories_are_accessed_only_from_service_config_or_repositories =
+            noClasses()
+                    .that().resideInAnyPackage(COMMON_MODULE_PACKAGES)
+                    .and().resideOutsideOfPackages(
+                            "io.github.ngirchev.opendaimon.common.config..",
+                            "io.github.ngirchev.opendaimon.common.repository..",
+                            "io.github.ngirchev.opendaimon.common.service..")
+                    .should().dependOnClassesThat().resideInAPackage("io.github.ngirchev.opendaimon.common.repository..")
+                    .because("repository access must stay behind services and explicit auto-configuration.");
+}
diff --git a/opendaimon-common/src/test/java/io/github/ngirchev/opendaimon/common/config/CoreAutoConfigMeterRegistryTest.java b/opendaimon-common/src/test/java/io/github/ngirchev/opendaimon/common/config/CoreAutoConfigMeterRegistryTest.java
new file mode 100644
index 00000000..ee691c43
--- /dev/null
+++ b/opendaimon-common/src/test/java/io/github/ngirchev/opendaimon/common/config/CoreAutoConfigMeterRegistryTest.java
@@ -0,0 +1,22 @@
+package io.github.ngirchev.opendaimon.common.config;
+
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+import io.github.ngirchev.opendaimon.common.meter.OpenDaimonMeterRegistry;
+import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
+import org.junit.jupiter.api.Test;
+
+class CoreAutoConfigMeterRegistryTest {
+
+    @Test
+    void createsSimpleMeterRegistryFallbackForConsumersWithoutActuator() {
+        CoreAutoConfig autoConfig = new CoreAutoConfig();
+
+        var meterRegistry = autoConfig.meterRegistry();
+        OpenDaimonMeterRegistry openDaimonMeterRegistry = autoConfig.openDaimonMeterRegistry(meterRegistry);
+
+        assertInstanceOf(SimpleMeterRegistry.class, meterRegistry);
+        assertNotNull(openDaimonMeterRegistry);
+    }
+}
diff --git a/opendaimon-gateway-mock/pom.xml b/opendaimon-gateway-mock/pom.xml
index ae9e1b98..b0b0b48c 100644
--- a/opendaimon-gateway-mock/pom.xml
+++ b/opendaimon-gateway-mock/pom.xml
@@ -40,45 +40,64 @@
             <version>${project.version}</version>
         </dependency>
 
-        <!-- Spring Boot -->
+        <!-- Spring Framework leaves -->
         <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter</artifactId>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-context</artifactId>
         </dependency>
 
+        <!-- Spring Boot core -->
         <dependency>
             <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-validation</artifactId>
+            <artifactId>spring-boot</artifactId>
         </dependency>
-
-        <!-- Other -->
         <dependency>
-            <groupId>org.projectlombok</groupId>
-            <artifactId>lombok</artifactId>
-            <optional>true</optional>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-autoconfigure</artifactId>
         </dependency>
 
-        <!-- Test -->
-        <dependency>
-            <groupId>io.github.ngirchev</groupId>
-            <artifactId>opendaimon-telegram</artifactId>
-            <version>${project.version}</version>
-            <scope>test</scope>
-        </dependency>
+        <!-- Annotations (@PostConstruct in MockGateway) -->
         <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-data-jpa</artifactId>
-            <scope>test</scope>
+            <groupId>jakarta.annotation</groupId>
+            <artifactId>jakarta.annotation-api</artifactId>
         </dependency>
+
+        <!-- Logging -->
         <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-test</artifactId>
-            <scope>test</scope>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
         </dependency>
+
+        <!-- Lombok: compile-only annotation processor -->
         <dependency>
-            <groupId>com.h2database</groupId>
-            <artifactId>h2</artifactId>
-            <scope>test</scope>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <scope>provided</scope>
+            <optional>true</optional>
         </dependency>
     </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-enforcer-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <id>enforce-dependency-graph</id>
+                        <configuration>
+                            <rules combine.children="append">
+                                <bannedDependencies>
+                                    <searchTransitive>true</searchTransitive>
+                                    <excludes>
+                                        <exclude>org.springframework.boot:spring-boot-starter*</exclude>
+                                    </excludes>
+                                </bannedDependencies>
+                            </rules>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
 </project>
diff --git a/opendaimon-rest/pom.xml b/opendaimon-rest/pom.xml
index 885ae2e6..617aabb2 100644
--- a/opendaimon-rest/pom.xml
+++ b/opendaimon-rest/pom.xml
@@ -37,42 +37,237 @@
             <version>${project.version}</version>
         </dependency>
 
+        <!-- Spring Framework leaves -->
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-beans</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-context</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-tx</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-web</artifactId>
+        </dependency>
+
+        <!-- Spring Boot core -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot</artifactId>
+        </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-web</artifactId>
+            <artifactId>spring-boot-autoconfigure</artifactId>
+        </dependency>
+
+        <!-- Spring Security (admin endpoints) -->
+        <dependency>
+            <groupId>org.springframework.security</groupId>
+            <artifactId>spring-security-config</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.security</groupId>
+            <artifactId>spring-security-web</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.security</groupId>
+            <artifactId>spring-security-core</artifactId>
+        </dependency>
+
+        <!-- Spring Data -->
+        <dependency>
+            <groupId>org.springframework.data</groupId>
+            <artifactId>spring-data-commons</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.data</groupId>
+            <artifactId>spring-data-jpa</artifactId>
+        </dependency>
+
+        <!-- Spring AI (REST DTO mappings) -->
+        <dependency>
+            <groupId>org.springframework.ai</groupId>
+            <artifactId>spring-ai-model</artifactId>
+        </dependency>
+
+        <!-- Reactor (streaming endpoints) -->
+        <dependency>
+            <groupId>io.projectreactor</groupId>
+            <artifactId>reactor-core</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.reactivestreams</groupId>
+            <artifactId>reactive-streams</artifactId>
+        </dependency>
+
+        <!-- Tomcat embedded core (used directly via Servlet API in security config).
+             Exclude tomcat-annotations-api: it provides duplicate jakarta.annotation.*
+             classes that would shadow jakarta.annotation-api and confuse dependency
+             analysis. -->
+        <dependency>
+            <groupId>org.apache.tomcat.embed</groupId>
+            <artifactId>tomcat-embed-core</artifactId>
             <exclusions>
                 <exclusion>
-                    <groupId>org.springframework.boot</groupId>
-                    <artifactId>spring-boot-starter-logging</artifactId>
+                    <groupId>org.apache.tomcat</groupId>
+                    <artifactId>tomcat-annotations-api</artifactId>
                 </exclusion>
             </exclusions>
         </dependency>
+
+        <!-- OpenAPI / Swagger annotations -->
         <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-security</artifactId>
+            <groupId>io.swagger.core.v3</groupId>
+            <artifactId>swagger-annotations-jakarta</artifactId>
         </dependency>
+
+        <!-- Validation -->
         <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-autoconfigure</artifactId>
+            <groupId>jakarta.validation</groupId>
+            <artifactId>jakarta.validation-api</artifactId>
         </dependency>
+
+        <!-- JPA / Persistence -->
         <dependency>
-            <groupId>org.springdoc</groupId>
-            <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
+            <groupId>jakarta.persistence</groupId>
+            <artifactId>jakarta.persistence-api</artifactId>
         </dependency>
+
+        <!-- Annotations -->
+        <dependency>
+            <groupId>jakarta.annotation</groupId>
+            <artifactId>jakarta.annotation-api</artifactId>
+        </dependency>
+
+        <!-- Database / Flyway core for module migrations -->
         <dependency>
             <groupId>org.flywaydb</groupId>
             <artifactId>flyway-core</artifactId>
         </dependency>
+
+        <!-- Logging -->
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
+        </dependency>
+
+        <!-- Lombok: compile-only annotation processor -->
         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>
+            <scope>provided</scope>
+            <optional>true</optional>
         </dependency>
 
-        <!-- Test Dependencies -->
+        <!-- Jackson -->
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+        </dependency>
+
+        <!-- Test -->
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-webmvc</artifactId>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-test</artifactId>
+            <artifactId>spring-boot-test-autoconfigure</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.jayway.jsonpath</groupId>
+            <artifactId>json-path</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.tngtech.archunit</groupId>
+            <artifactId>archunit</artifactId>
+            <version>${archunit.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.tngtech.archunit</groupId>
+            <artifactId>archunit-junit5-api</artifactId>
+            <version>${archunit.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.tngtech.archunit</groupId>
+            <artifactId>archunit-junit5-engine</artifactId>
+            <version>${archunit.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-junit-jupiter</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.hamcrest</groupId>
+            <artifactId>hamcrest</artifactId>
             <scope>test</scope>
         </dependency>
     </dependencies>
-</project> 
\ No newline at end of file
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-dependency-plugin</artifactId>
+                <configuration>
+                    <ignoredUnusedDeclaredDependencies>
+                        <!-- Runtime support for @WebMvcTest / MockMvc JSON assertions.
+                             The bytecode analyzer cannot see classes loaded reflectively
+                             by Spring's test infrastructure and JsonPath result matchers. -->
+                        <ignored>org.springframework:spring-webmvc</ignored>
+                        <ignored>com.jayway.jsonpath:json-path</ignored>
+                        <!-- ArchUnit JUnit engine is discovered by JUnit Platform at runtime;
+                             no test class imports it directly. -->
+                        <ignored>com.tngtech.archunit:archunit-junit5-engine</ignored>
+                    </ignoredUnusedDeclaredDependencies>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-enforcer-plugin</artifactId>
+                <configuration>
+                    <rules>
+                        <bannedDependencies>
+                            <searchTransitive>true</searchTransitive>
+                            <excludes>
+                                <exclude>org.springframework.boot:spring-boot-starter*</exclude>
+                            </excludes>
+                        </bannedDependencies>
+                    </rules>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>
diff --git a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/handler/RestChatCommand.java b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/command/RestChatCommand.java
similarity index 70%
rename from opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/handler/RestChatCommand.java
rename to opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/command/RestChatCommand.java
index c4401147..7ffe1f56 100644
--- a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/handler/RestChatCommand.java
+++ b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/command/RestChatCommand.java
@@ -1,11 +1,13 @@
-package io.github.ngirchev.opendaimon.rest.handler;
+package io.github.ngirchev.opendaimon.rest.command;
 
 import jakarta.servlet.http.HttpServletRequest;
 import io.github.ngirchev.opendaimon.common.command.IChatCommand;
-import io.github.ngirchev.opendaimon.rest.dto.ChatRequestDto;
 
 public record RestChatCommand(
-        ChatRequestDto chatRequestDto,
+        String message,
+        String assistantRole,
+        String model,
+        String email,
         RestChatCommandType commandType,
         HttpServletRequest request,
         Long userId
@@ -18,11 +20,11 @@ public Long userId() {
 
     @Override
     public String userText() {
-        return chatRequestDto != null ? chatRequestDto.message() : null;
+        return message;
     }
 
     @Override
     public boolean stream() {
         return commandType == RestChatCommandType.STREAM;
     }
-}
\ No newline at end of file
+}
diff --git a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/handler/RestChatCommandType.java b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/command/RestChatCommandType.java
similarity index 74%
rename from opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/handler/RestChatCommandType.java
rename to opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/command/RestChatCommandType.java
index ccf99e56..24c5f176 100644
--- a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/handler/RestChatCommandType.java
+++ b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/command/RestChatCommandType.java
@@ -1,4 +1,4 @@
-package io.github.ngirchev.opendaimon.rest.handler;
+package io.github.ngirchev.opendaimon.rest.command;
 
 import io.github.ngirchev.opendaimon.common.command.ICommandType;
 
diff --git a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/config/RestAutoConfig.java b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/config/RestAutoConfig.java
index dae3c67b..305a5f57 100644
--- a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/config/RestAutoConfig.java
+++ b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/config/RestAutoConfig.java
@@ -1,6 +1,7 @@
 package io.github.ngirchev.opendaimon.rest.config;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
+import org.springframework.beans.factory.ObjectProvider;
 import org.springframework.boot.autoconfigure.AutoConfiguration;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
@@ -180,8 +181,8 @@ public AdminQueryService adminQueryService(
     @ConditionalOnMissingBean
     public AdminAttachmentService adminAttachmentService(
             OpenDaimonMessageRepository messageRepository,
-            FileStorageService fileStorageService) {
-        return new AdminAttachmentService(messageRepository, fileStorageService);
+            ObjectProvider<FileStorageService> fileStorageServiceProvider) {
+        return new AdminAttachmentService(messageRepository, fileStorageServiceProvider.getIfAvailable());
     }
 
     @Bean
@@ -208,4 +209,3 @@ public AdminMeController adminMeController() {
         return new AdminMeController();
     }
 }
-
diff --git a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/controller/AdminConversationController.java b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/controller/AdminConversationController.java
index 8ce2c9ca..da199a79 100644
--- a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/controller/AdminConversationController.java
+++ b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/controller/AdminConversationController.java
@@ -1,11 +1,19 @@
 package io.github.ngirchev.opendaimon.rest.controller;
 
 import io.github.ngirchev.opendaimon.common.model.ThreadScopeKind;
+import io.github.ngirchev.opendaimon.rest.dto.admin.AttachmentRefDto;
 import io.github.ngirchev.opendaimon.rest.dto.admin.ConversationSummaryDto;
 import io.github.ngirchev.opendaimon.rest.dto.admin.MessageDetailDto;
 import io.github.ngirchev.opendaimon.rest.dto.admin.MessageSummaryDto;
 import io.github.ngirchev.opendaimon.rest.dto.admin.PageResponseDto;
+import io.github.ngirchev.opendaimon.rest.dto.admin.UserSummaryDto;
 import io.github.ngirchev.opendaimon.rest.service.AdminQueryService;
+import io.github.ngirchev.opendaimon.rest.service.model.AdminAttachmentRef;
+import io.github.ngirchev.opendaimon.rest.service.model.AdminConversationSummary;
+import io.github.ngirchev.opendaimon.rest.service.model.AdminMessageDetail;
+import io.github.ngirchev.opendaimon.rest.service.model.AdminMessageSummary;
+import io.github.ngirchev.opendaimon.rest.service.model.AdminPageResponse;
+import io.github.ngirchev.opendaimon.rest.service.model.AdminUserSummary;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.RequiredArgsConstructor;
@@ -53,24 +61,103 @@ public ResponseEntity<PageResponseDto<ConversationSummaryDto>> listConversations
                 boundedPage,
                 boundedSize == 0 ? DEFAULT_PAGE_SIZE : boundedSize,
                 Sort.by(Sort.Direction.DESC, "lastActivityAt"));
-        return ResponseEntity.ok(adminQueryService.listConversations(userId, scopeKind, isActive, pageable));
+        return ResponseEntity.ok(toConversationPageDto(adminQueryService.listConversations(userId, scopeKind, isActive, pageable)));
     }
 
     @GetMapping("/conversations/{id}")
     @Operation(summary = "Get conversation metadata")
     public ResponseEntity<ConversationSummaryDto> getConversation(@PathVariable Long id) {
-        return ResponseEntity.ok(adminQueryService.getConversation(id));
+        return ResponseEntity.ok(toDto(adminQueryService.getConversation(id)));
     }
 
     @GetMapping("/conversations/{id}/messages")
     @Operation(summary = "List messages of a conversation", description = "Sorted by sequenceNumber asc")
     public ResponseEntity<List<MessageSummaryDto>> listMessages(@PathVariable Long id) {
-        return ResponseEntity.ok(adminQueryService.listMessages(id));
+        return ResponseEntity.ok(adminQueryService.listMessages(id).stream()
+                .map(AdminConversationController::toDto)
+                .toList());
     }
 
     @GetMapping("/messages/{id}")
     @Operation(summary = "Get single message with attachments metadata")
     public ResponseEntity<MessageDetailDto> getMessage(@PathVariable Long id) {
-        return ResponseEntity.ok(adminQueryService.getMessage(id));
+        return ResponseEntity.ok(toDto(adminQueryService.getMessage(id)));
+    }
+
+    private static PageResponseDto<ConversationSummaryDto> toConversationPageDto(
+            AdminPageResponse<AdminConversationSummary> page) {
+        return new PageResponseDto<>(
+                page.content().stream().map(AdminConversationController::toDto).toList(),
+                page.page(),
+                page.size(),
+                page.totalElements(),
+                page.totalPages());
+    }
+
+    private static ConversationSummaryDto toDto(AdminConversationSummary summary) {
+        return new ConversationSummaryDto(
+                summary.id(),
+                summary.threadKey(),
+                summary.title(),
+                summary.scopeKind(),
+                summary.scopeId(),
+                summary.totalMessages(),
+                summary.totalTokens(),
+                summary.isActive(),
+                summary.lastActivityAt(),
+                summary.createdAt(),
+                toDto(summary.user()));
+    }
+
+    private static MessageSummaryDto toDto(AdminMessageSummary summary) {
+        return new MessageSummaryDto(
+                summary.id(),
+                summary.sequenceNumber(),
+                summary.role(),
+                summary.requestType(),
+                summary.status(),
+                summary.contentPreview(),
+                summary.attachmentCount(),
+                summary.createdAt());
+    }
+
+    private static MessageDetailDto toDto(AdminMessageDetail detail) {
+        return new MessageDetailDto(
+                detail.id(),
+                detail.threadId(),
+                detail.sequenceNumber(),
+                detail.role(),
+                detail.content(),
+                detail.requestType(),
+                detail.status(),
+                detail.serviceName(),
+                detail.tokenCount(),
+                detail.processingTimeMs(),
+                detail.errorMessage(),
+                detail.telegramMessageId(),
+                detail.createdAt(),
+                detail.attachments().stream().map(AdminConversationController::toDto).toList(),
+                detail.metadata(),
+                detail.responseData(),
+                toDto(detail.user()));
+    }
+
+    private static AttachmentRefDto toDto(AdminAttachmentRef ref) {
+        return new AttachmentRefDto(ref.storageKey(), ref.mimeType(), ref.filename(), ref.expiresAt());
+    }
+
+    private static UserSummaryDto toDto(AdminUserSummary user) {
+        if (user == null) {
+            return null;
+        }
+        return new UserSummaryDto(
+                user.id(),
+                user.userType(),
+                user.username(),
+                user.firstName(),
+                user.lastName(),
+                user.emailOrTelegramId(),
+                user.isAdmin(),
+                user.isBlocked());
     }
 }
diff --git a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/controller/AdminUserController.java b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/controller/AdminUserController.java
index a76a4338..d87577e3 100644
--- a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/controller/AdminUserController.java
+++ b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/controller/AdminUserController.java
@@ -3,6 +3,8 @@
 import io.github.ngirchev.opendaimon.rest.dto.admin.PageResponseDto;
 import io.github.ngirchev.opendaimon.rest.dto.admin.UserSummaryDto;
 import io.github.ngirchev.opendaimon.rest.service.AdminQueryService;
+import io.github.ngirchev.opendaimon.rest.service.model.AdminPageResponse;
+import io.github.ngirchev.opendaimon.rest.service.model.AdminUserSummary;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.RequiredArgsConstructor;
@@ -38,6 +40,27 @@ public ResponseEntity<PageResponseDto<UserSummaryDto>> listUsers(
         int boundedSize = Math.min(Math.max(size, 1), MAX_PAGE_SIZE);
         int boundedPage = Math.max(page, 0);
         PageRequest pageable = PageRequest.of(boundedPage, boundedSize, Sort.by("id"));
-        return ResponseEntity.ok(adminQueryService.listUsers(search, pageable));
+        return ResponseEntity.ok(toDto(adminQueryService.listUsers(search, pageable)));
+    }
+
+    private static PageResponseDto<UserSummaryDto> toDto(AdminPageResponse<AdminUserSummary> page) {
+        return new PageResponseDto<>(
+                page.content().stream().map(AdminUserController::toDto).toList(),
+                page.page(),
+                page.size(),
+                page.totalElements(),
+                page.totalPages());
+    }
+
+    private static UserSummaryDto toDto(AdminUserSummary user) {
+        return new UserSummaryDto(
+                user.id(),
+                user.userType(),
+                user.username(),
+                user.firstName(),
+                user.lastName(),
+                user.emailOrTelegramId(),
+                user.isAdmin(),
+                user.isBlocked());
     }
 }
diff --git a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/controller/SessionController.java b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/controller/SessionController.java
index cf8b4069..cab7bce0 100644
--- a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/controller/SessionController.java
+++ b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/controller/SessionController.java
@@ -16,8 +16,10 @@
 import io.github.ngirchev.opendaimon.rest.exception.UnauthorizedException;
 import io.github.ngirchev.opendaimon.rest.service.ChatService;
 import io.github.ngirchev.opendaimon.rest.service.RestAuthorizationService;
+import io.github.ngirchev.opendaimon.rest.service.model.ChatMessage;
+import io.github.ngirchev.opendaimon.rest.service.model.ChatResponse;
+import io.github.ngirchev.opendaimon.rest.service.model.ChatSession;
 
-import java.time.Duration;
 import java.util.List;
 
 /**
@@ -44,13 +46,12 @@ public ResponseEntity<ChatResponseDto<String>> sendMessageToNewChat(
             HttpServletRequest httpRequest,
             HttpSession session) {
         String email = getEmailFromSessionOrRequest(session, request.email(), httpRequest.getLocale().getLanguage());
-        return ResponseEntity.ok(
-                chatService.sendMessageToNewChat(
+        ChatResponse<String> response = chatService.sendMessageToNewChat(
                         request.message(),
                         restAuthorizationService.authorize(email, httpRequest.getLocale().getLanguage()),
                         httpRequest,
-                        false)
-        );
+                false);
+        return ResponseEntity.ok(toDto(response));
     }
 
     @PostMapping("/{sessionId}")
@@ -61,13 +62,13 @@ public ResponseEntity<ChatResponseDto<String>> sendMessage(
             HttpServletRequest httpRequest,
             HttpSession session) {
         String email = getEmailFromSessionOrRequest(session, request.email(), httpRequest.getLocale().getLanguage());
-        return ResponseEntity.ok(chatService.sendMessage(
+        ChatResponse<String> response = chatService.sendMessage(
                 sessionId,
                 request.message(),
                 restAuthorizationService.authorize(email, httpRequest.getLocale().getLanguage()),
                 httpRequest,
-                false)
-        );
+                false);
+        return ResponseEntity.ok(toDto(response));
     }
 
 //    @PostMapping(value = "/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
@@ -94,7 +95,7 @@ public Flux<ServerSentEvent<String>> sendMessageToNewChatStream(
             HttpSession session) {
         String email = getEmailFromSessionOrRequest(session, request.email(), httpRequest.getLocale().getLanguage());
         var user = restAuthorizationService.authorize(email, httpRequest.getLocale().getLanguage());
-        ChatResponseDto<Flux<String>> response = chatService.sendMessageToNewChat(request.message(), user, httpRequest, true);
+        ChatResponse<Flux<String>> response = chatService.sendMessageToNewChat(request.message(), user, httpRequest, true);
         String sessionId = response.sessionId();
         // Send sessionId in first event with type "metadata"
         ServerSentEvent<String> sessionEvent = ServerSentEvent.<String>builder()
@@ -119,7 +120,7 @@ public Flux<ServerSentEvent<String>> sendMessageStream(
             HttpSession session) {
         String email = getEmailFromSessionOrRequest(session, request.email(), httpRequest.getLocale().getLanguage());
         var user = restAuthorizationService.authorize(email, httpRequest.getLocale().getLanguage());
-        ChatResponseDto<Flux<String>> response = chatService.sendMessage(sessionId, request.message(), user, httpRequest, true);
+        ChatResponse<Flux<String>> response = chatService.sendMessage(sessionId, request.message(), user, httpRequest, true);
         // Do not use delayElements - send data as soon as it arrives
         return response.message()
                 // Convert to SSE
@@ -134,7 +135,9 @@ public ResponseEntity<List<ChatSessionDto>> getSessions(
             HttpServletRequest httpRequest) {
         String userEmail = getEmailFromSessionOrRequest(session, email, httpRequest.getLocale().getLanguage());
         var user = restAuthorizationService.authorize(userEmail, httpRequest.getLocale().getLanguage());
-        return ResponseEntity.ok(chatService.getSessions(user));
+        return ResponseEntity.ok(chatService.getSessions(user).stream()
+                .map(SessionController::toDto)
+                .toList());
     }
 
     @GetMapping("/{sessionId}/messages")
@@ -146,7 +149,9 @@ public ResponseEntity<ChatHistoryResponseDto> getSessionMessages(
             HttpServletRequest httpRequest) {
         String userEmail = getEmailFromSessionOrRequest(session, email, httpRequest.getLocale().getLanguage());
         var user = restAuthorizationService.authorize(userEmail, httpRequest.getLocale().getLanguage());
-        List<ChatMessageDto> messages = chatService.getChatHistory(sessionId, user);
+        List<ChatMessageDto> messages = chatService.getChatHistory(sessionId, user).stream()
+                .map(SessionController::toDto)
+                .toList();
         return ResponseEntity.ok(new ChatHistoryResponseDto(sessionId, messages));
     }
 
@@ -182,5 +187,16 @@ private String getEmailFromSessionOrRequest(HttpSession session, String emailFro
         }
         throw new UnauthorizedException(messageLocalizationService.getMessage("rest.auth.email.required", languageCode));
     }
-}
 
+    private static <T> ChatResponseDto<T> toDto(ChatResponse<T> response) {
+        return new ChatResponseDto<>(response.message(), response.sessionId());
+    }
+
+    private static ChatSessionDto toDto(ChatSession session) {
+        return new ChatSessionDto(session.sessionId(), session.name(), session.createdAt());
+    }
+
+    private static ChatMessageDto toDto(ChatMessage message) {
+        return new ChatMessageDto(message.role(), message.content());
+    }
+}
diff --git a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/handler/RestChatHandlerSupport.java b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/handler/RestChatHandlerSupport.java
index c6d7daca..f6162631 100644
--- a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/handler/RestChatHandlerSupport.java
+++ b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/handler/RestChatHandlerSupport.java
@@ -10,6 +10,7 @@
 import io.github.ngirchev.opendaimon.common.service.OpenDaimonMessageService;
 import io.github.ngirchev.opendaimon.common.service.AIUtils;
 import io.github.ngirchev.opendaimon.common.service.MessageLocalizationService;
+import io.github.ngirchev.opendaimon.rest.command.RestChatCommand;
 
 import io.github.ngirchev.opendaimon.common.SupportedLanguages;
 
diff --git a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/handler/RestChatMessageCommandHandler.java b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/handler/RestChatMessageCommandHandler.java
index 3d09b832..d62ca7b3 100644
--- a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/handler/RestChatMessageCommandHandler.java
+++ b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/handler/RestChatMessageCommandHandler.java
@@ -16,6 +16,8 @@
 import io.github.ngirchev.opendaimon.common.service.*;
 import io.github.ngirchev.opendaimon.bulkhead.exception.AccessDeniedException;
 import io.github.ngirchev.opendaimon.common.exception.UserMessageTooLongException;
+import io.github.ngirchev.opendaimon.rest.command.RestChatCommand;
+import io.github.ngirchev.opendaimon.rest.command.RestChatCommandType;
 import io.github.ngirchev.opendaimon.rest.model.RestUser;
 import io.github.ngirchev.opendaimon.rest.service.RestMessageService;
 import io.github.ngirchev.opendaimon.rest.service.RestUserService;
@@ -31,7 +33,8 @@
 @Slf4j
 @RequiredArgsConstructor
 public class RestChatMessageCommandHandler implements
-        ICommandHandler<RestChatCommandType, RestChatCommand, String> {
+        ICommandHandler<RestChatCommandType,
+                RestChatCommand, String> {
 
     private final RestMessageService restMessageService;
     private final RestUserService restUserService;
@@ -61,12 +64,12 @@ public String handle(RestChatCommand command) {
             String lang = RestChatHandlerSupport.getRequestLanguage(command);
             RestUser user = restUserService.findById(command.userId())
                     .orElseThrow(() -> new RuntimeException(support.getMessageLocalizationService().getMessage("rest.user.not.found", lang, command.userId())));
-            String assistantRoleContent = command.chatRequestDto().assistantRole() != null
-                    ? command.chatRequestDto().assistantRole()
+            String assistantRoleContent = command.assistantRole() != null
+                    ? command.assistantRole()
                     : null;
             userMessage = restMessageService.saveUserMessage(
                     user,
-                    command.chatRequestDto().message(),
+                    command.message(),
                     RequestType.TEXT,
                     assistantRoleContent,
                     command.request());
diff --git a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/handler/RestChatStreamMessageCommandHandler.java b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/handler/RestChatStreamMessageCommandHandler.java
index 54a97919..b37f7b74 100644
--- a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/handler/RestChatStreamMessageCommandHandler.java
+++ b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/handler/RestChatStreamMessageCommandHandler.java
@@ -16,6 +16,8 @@
 import io.github.ngirchev.opendaimon.common.command.ICommandHandler;
 import io.github.ngirchev.opendaimon.common.model.*;
 import io.github.ngirchev.opendaimon.common.service.*;
+import io.github.ngirchev.opendaimon.rest.command.RestChatCommand;
+import io.github.ngirchev.opendaimon.rest.command.RestChatCommandType;
 import io.github.ngirchev.opendaimon.rest.model.RestUser;
 import io.github.ngirchev.opendaimon.rest.service.RestMessageService;
 import io.github.ngirchev.opendaimon.rest.service.RestUserService;
@@ -32,7 +34,8 @@
 @Slf4j
 @RequiredArgsConstructor
 public class RestChatStreamMessageCommandHandler implements
-        ICommandHandler<RestChatCommandType, RestChatCommand, Flux<String>> {
+        ICommandHandler<RestChatCommandType,
+                RestChatCommand, Flux<String>> {
 
     private final RestMessageService restMessageService;
     private final RestUserService restUserService;
@@ -62,12 +65,12 @@ public Flux<String> handle(RestChatCommand command) {
             String lang = RestChatHandlerSupport.getRequestLanguage(command);
             RestUser user = restUserService.findById(command.userId())
                     .orElseThrow(() -> new RuntimeException(support.getMessageLocalizationService().getMessage("rest.user.not.found", lang, command.userId())));
-            String assistantRoleContent = command.chatRequestDto().assistantRole() != null
-                    ? command.chatRequestDto().assistantRole()
+            String assistantRoleContent = command.assistantRole() != null
+                    ? command.assistantRole()
                     : null;
             userMessage = restMessageService.saveUserMessage(
                     user,
-                    command.chatRequestDto().message(),
+                    command.message(),
                     RequestType.TEXT,
                     assistantRoleContent,
                     command.request());
diff --git a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/repository/AdminConversationRepository.java b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/repository/AdminConversationRepository.java
index 778a35c8..7868e739 100644
--- a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/repository/AdminConversationRepository.java
+++ b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/repository/AdminConversationRepository.java
@@ -7,7 +7,6 @@
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.query.Param;
-import org.springframework.stereotype.Repository;
 
 /**
  * Admin-scope queries over ConversationThread.
@@ -15,7 +14,6 @@
  * core common contract — this keeps opendaimon-common untouched while still reusing
  * the ConversationThread entity.
  */
-@Repository
 public interface AdminConversationRepository extends JpaRepository<ConversationThread, Long> {
 
     /**
diff --git a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/repository/AdminUserRepository.java b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/repository/AdminUserRepository.java
index 9b060ce5..32ae9743 100644
--- a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/repository/AdminUserRepository.java
+++ b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/repository/AdminUserRepository.java
@@ -6,13 +6,11 @@
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.query.Param;
-import org.springframework.stereotype.Repository;
 
 /**
  * Polymorphic lookup over the base User table for admin filter dropdowns.
  * Returns TelegramUser / RestUser subclasses transparently thanks to JOINED inheritance.
  */
-@Repository
 public interface AdminUserRepository extends JpaRepository<User, Long> {
 
     /**
diff --git a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/repository/RestUserRepository.java b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/repository/RestUserRepository.java
index 10270b91..4acdee62 100644
--- a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/repository/RestUserRepository.java
+++ b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/repository/RestUserRepository.java
@@ -1,12 +1,10 @@
 package io.github.ngirchev.opendaimon.rest.repository;
 
 import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
 import io.github.ngirchev.opendaimon.rest.model.RestUser;
 
 import java.util.Optional;
 
-@Repository
 public interface RestUserRepository extends JpaRepository<RestUser, Long> {
     
     Optional<RestUser> findByEmail(String email);
diff --git a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/AdminAttachmentService.java b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/AdminAttachmentService.java
index 77acacc8..c6b6d300 100644
--- a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/AdminAttachmentService.java
+++ b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/AdminAttachmentService.java
@@ -37,6 +37,10 @@ public Optional<ResolvedAttachment> resolve(Long messageId, String storageKey) {
         if (messageId == null || storageKey == null || storageKey.isBlank()) {
             return Optional.empty();
         }
+        if (fileStorageService == null) {
+            log.warn("Admin requested attachment storageKey={} but file storage is disabled", storageKey);
+            return Optional.empty();
+        }
         Optional<OpenDaimonMessage> messageOpt = messageRepository.findById(messageId);
         if (messageOpt.isEmpty()) {
             log.warn("Admin requested attachment for unknown messageId={}", messageId);
diff --git a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/AdminQueryService.java b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/AdminQueryService.java
index bc6cb37f..41dc1c6e 100644
--- a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/AdminQueryService.java
+++ b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/AdminQueryService.java
@@ -5,16 +5,16 @@
 import io.github.ngirchev.opendaimon.common.model.ThreadScopeKind;
 import io.github.ngirchev.opendaimon.common.model.User;
 import io.github.ngirchev.opendaimon.common.repository.OpenDaimonMessageRepository;
-import io.github.ngirchev.opendaimon.rest.dto.admin.AttachmentRefDto;
-import io.github.ngirchev.opendaimon.rest.dto.admin.ConversationSummaryDto;
-import io.github.ngirchev.opendaimon.rest.dto.admin.MessageDetailDto;
-import io.github.ngirchev.opendaimon.rest.dto.admin.MessageSummaryDto;
-import io.github.ngirchev.opendaimon.rest.dto.admin.PageResponseDto;
-import io.github.ngirchev.opendaimon.rest.dto.admin.UserSummaryDto;
 import io.github.ngirchev.opendaimon.rest.exception.UnauthorizedException;
 import io.github.ngirchev.opendaimon.rest.model.RestUser;
 import io.github.ngirchev.opendaimon.rest.repository.AdminConversationRepository;
 import io.github.ngirchev.opendaimon.rest.repository.AdminUserRepository;
+import io.github.ngirchev.opendaimon.rest.service.model.AdminAttachmentRef;
+import io.github.ngirchev.opendaimon.rest.service.model.AdminConversationSummary;
+import io.github.ngirchev.opendaimon.rest.service.model.AdminMessageDetail;
+import io.github.ngirchev.opendaimon.rest.service.model.AdminMessageSummary;
+import io.github.ngirchev.opendaimon.rest.service.model.AdminPageResponse;
+import io.github.ngirchev.opendaimon.rest.service.model.AdminUserSummary;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.data.domain.Page;
@@ -45,26 +45,26 @@ public class AdminQueryService {
     private final OpenDaimonMessageRepository messageRepository;
 
     @Transactional(readOnly = true)
-    public PageResponseDto<ConversationSummaryDto> listConversations(
+    public AdminPageResponse<AdminConversationSummary> listConversations(
             Long userId, ThreadScopeKind scopeKind, Boolean isActive, Pageable pageable) {
         Page<ConversationThread> page = adminConversationRepository
                 .findAllWithFilters(userId, scopeKind, isActive, pageable);
-        return PageResponseDto.from(page.map(this::toConversationSummary));
+        return AdminPageResponse.from(page.map(this::toConversationSummary));
     }
 
     @Transactional(readOnly = true)
-    public ConversationSummaryDto getConversation(Long threadId) {
+    public AdminConversationSummary getConversation(Long threadId) {
         ConversationThread thread = adminConversationRepository.findByIdWithUser(threadId)
                 .orElseThrow(() -> new UnauthorizedException("Conversation not found: " + threadId));
         return toConversationSummary(thread);
     }
 
     @Transactional(readOnly = true)
-    public List<MessageSummaryDto> listMessages(Long threadId) {
+    public List<AdminMessageSummary> listMessages(Long threadId) {
         ConversationThread thread = adminConversationRepository.findByIdWithUser(threadId)
                 .orElseThrow(() -> new UnauthorizedException("Conversation not found: " + threadId));
         List<OpenDaimonMessage> messages = messageRepository.findByThreadOrderBySequenceNumberAsc(thread);
-        List<MessageSummaryDto> result = new ArrayList<>(messages.size());
+        List<AdminMessageSummary> result = new ArrayList<>(messages.size());
         for (OpenDaimonMessage m : messages) {
             result.add(toMessageSummary(m));
         }
@@ -72,20 +72,20 @@ public List<MessageSummaryDto> listMessages(Long threadId) {
     }
 
     @Transactional(readOnly = true)
-    public MessageDetailDto getMessage(Long messageId) {
+    public AdminMessageDetail getMessage(Long messageId) {
         OpenDaimonMessage message = messageRepository.findById(messageId)
                 .orElseThrow(() -> new UnauthorizedException("Message not found: " + messageId));
         return toMessageDetail(message);
     }
 
     @Transactional(readOnly = true)
-    public PageResponseDto<UserSummaryDto> listUsers(String search, Pageable pageable) {
+    public AdminPageResponse<AdminUserSummary> listUsers(String search, Pageable pageable) {
         Page<User> page = adminUserRepository.searchAll(search, pageable);
-        return PageResponseDto.from(page.map(this::toUserSummary));
+        return AdminPageResponse.from(page.map(this::toUserSummary));
     }
 
-    private ConversationSummaryDto toConversationSummary(ConversationThread t) {
-        return new ConversationSummaryDto(
+    private AdminConversationSummary toConversationSummary(ConversationThread t) {
+        return new AdminConversationSummary(
                 t.getId(),
                 t.getThreadKey(),
                 t.getTitle(),
@@ -100,8 +100,8 @@ private ConversationSummaryDto toConversationSummary(ConversationThread t) {
         );
     }
 
-    private MessageSummaryDto toMessageSummary(OpenDaimonMessage m) {
-        return new MessageSummaryDto(
+    private AdminMessageSummary toMessageSummary(OpenDaimonMessage m) {
+        return new AdminMessageSummary(
                 m.getId(),
                 m.getSequenceNumber(),
                 m.getRole() != null ? m.getRole().name() : null,
@@ -113,8 +113,8 @@ private MessageSummaryDto toMessageSummary(OpenDaimonMessage m) {
         );
     }
 
-    private MessageDetailDto toMessageDetail(OpenDaimonMessage m) {
-        return new MessageDetailDto(
+    private AdminMessageDetail toMessageDetail(OpenDaimonMessage m) {
+        return new AdminMessageDetail(
                 m.getId(),
                 m.getThread() != null ? m.getThread().getId() : null,
                 m.getSequenceNumber(),
@@ -135,13 +135,13 @@ private MessageDetailDto toMessageDetail(OpenDaimonMessage m) {
         );
     }
 
-    private UserSummaryDto toUserSummary(User user) {
+    private AdminUserSummary toUserSummary(User user) {
         if (user == null) {
             return null;
         }
         String discriminator = resolveUserType(user);
         String identity = resolveIdentity(user);
-        return new UserSummaryDto(
+        return new AdminUserSummary(
                 user.getId(),
                 discriminator,
                 user.getUsername(),
@@ -186,17 +186,17 @@ private String invokeTelegramId(User user) {
         }
     }
 
-    private List<AttachmentRefDto> toAttachmentRefs(List<Map<String, Object>> raw) {
+    private List<AdminAttachmentRef> toAttachmentRefs(List<Map<String, Object>> raw) {
         if (raw == null || raw.isEmpty()) {
             return List.of();
         }
-        List<AttachmentRefDto> refs = new ArrayList<>(raw.size());
+        List<AdminAttachmentRef> refs = new ArrayList<>(raw.size());
         for (Map<String, Object> entry : raw) {
             String storageKey = asString(entry.get(ATTACH_KEY_STORAGE));
             if (storageKey == null) {
                 continue;
             }
-            refs.add(new AttachmentRefDto(
+            refs.add(new AdminAttachmentRef(
                     storageKey,
                     asString(entry.get(ATTACH_KEY_MIME)),
                     asString(entry.get(ATTACH_KEY_FILENAME)),
diff --git a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/ChatService.java b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/ChatService.java
index 10f0ed7f..833304bb 100644
--- a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/ChatService.java
+++ b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/ChatService.java
@@ -13,14 +13,13 @@
 import io.github.ngirchev.opendaimon.bulkhead.service.IUserPriorityService;
 import io.github.ngirchev.opendaimon.common.service.CommandSyncService;
 import io.github.ngirchev.opendaimon.common.service.ConversationThreadService;
-import io.github.ngirchev.opendaimon.rest.handler.RestChatCommand;
-import io.github.ngirchev.opendaimon.rest.handler.RestChatCommandType;
-import io.github.ngirchev.opendaimon.rest.dto.ChatRequestDto;
-import io.github.ngirchev.opendaimon.rest.dto.ChatResponseDto;
-import io.github.ngirchev.opendaimon.rest.dto.ChatSessionDto;
-import io.github.ngirchev.opendaimon.rest.dto.ChatMessageDto;
+import io.github.ngirchev.opendaimon.rest.command.RestChatCommand;
+import io.github.ngirchev.opendaimon.rest.command.RestChatCommandType;
 import io.github.ngirchev.opendaimon.rest.model.RestUser;
 import io.github.ngirchev.opendaimon.rest.exception.UnauthorizedException;
+import io.github.ngirchev.opendaimon.rest.service.model.ChatMessage;
+import io.github.ngirchev.opendaimon.rest.service.model.ChatResponse;
+import io.github.ngirchev.opendaimon.rest.service.model.ChatSession;
 
 import java.util.List;
 import java.util.stream.Collectors;
@@ -45,7 +44,7 @@ public class ChatService {
      * Sends message to new chat (creates new session)
      */
     @Transactional
-    public <T> ChatResponseDto<T> sendMessageToNewChat(String message, RestUser user, HttpServletRequest request, boolean isStream) {
+    public <T> ChatResponse<T> sendMessageToNewChat(String message, RestUser user, HttpServletRequest request, boolean isStream) {
         // Close current active thread (if any)
         threadRepository.findMostRecentActiveThread(user)
                 .ifPresent(conversationThreadService::closeThread);
@@ -54,7 +53,7 @@ public <T> ChatResponseDto<T> sendMessageToNewChat(String message, RestUser user
         ConversationThread thread = conversationThreadService.createNewThread(user);
 
         // Send message
-        return new ChatResponseDto<>(
+        return new ChatResponse<>(
                 sendMessageInternal(thread.getThreadKey(), message, user, request, isStream),
                 thread.getThreadKey()
         );
@@ -64,7 +63,7 @@ public <T> ChatResponseDto<T> sendMessageToNewChat(String message, RestUser user
      * Sends message to existing session
      */
     @Transactional
-    public <T> ChatResponseDto<T> sendMessage(String sessionId, String message, RestUser user, HttpServletRequest request, boolean isStream) {
+    public <T> ChatResponse<T> sendMessage(String sessionId, String message, RestUser user, HttpServletRequest request, boolean isStream) {
         ConversationThread thread = getThreadBySessionId(sessionId);
 
         // Verify thread belongs to user
@@ -76,7 +75,7 @@ public <T> ChatResponseDto<T> sendMessage(String sessionId, String message, Rest
         conversationThreadService.activateThread(user, thread);
 
         // Send message
-        return new ChatResponseDto<>(
+        return new ChatResponse<>(
                 sendMessageInternal(thread.getThreadKey(), message, user, request, isStream),
                 thread.getThreadKey()
         );
@@ -87,9 +86,11 @@ public <T> ChatResponseDto<T> sendMessage(String sessionId, String message, Rest
      */
     private <T> T sendMessageInternal(String sessionId, String message, RestUser user, HttpServletRequest request, boolean isStream) {
         // Create ChatRequest and send via existing handler
-        ChatRequestDto chatRequestDto = new ChatRequestDto(message, null, null, user.getEmail());
         RestChatCommand command = new RestChatCommand(
-                chatRequestDto,
+                message,
+                null,
+                null,
+                user.getEmail(),
                 isStream ? RestChatCommandType.STREAM : RestChatCommandType.MESSAGE,
                 request,
                 user.getId()
@@ -102,11 +103,11 @@ private <T> T sendMessageInternal(String sessionId, String message, RestUser use
      * Gets list of all user sessions
      */
     @Transactional(readOnly = true)
-    public List<ChatSessionDto> getSessions(RestUser user) {
+    public List<ChatSession> getSessions(RestUser user) {
         List<ConversationThread> threads = threadRepository.findByUserOrderByLastActivityAtDesc(user);
 
         return threads.stream()
-                .map(thread -> new ChatSessionDto(
+                .map(thread -> new ChatSession(
                         thread.getThreadKey(),
                         thread.getTitle() != null ? thread.getTitle() : "Untitled",
                         thread.getCreatedAt()
@@ -118,7 +119,7 @@ public List<ChatSessionDto> getSessions(RestUser user) {
      * Gets message history for session
      */
     @Transactional(readOnly = true)
-    public List<ChatMessageDto> getChatHistory(String sessionId, RestUser user) {
+    public List<ChatMessage> getChatHistory(String sessionId, RestUser user) {
         ConversationThread thread = getThreadBySessionId(sessionId);
 
         // Verify thread belongs to user
@@ -130,7 +131,7 @@ public List<ChatMessageDto> getChatHistory(String sessionId, RestUser user) {
 
         return messages.stream()
                 .filter(msg -> msg.getRole() != MessageRole.SYSTEM) // Exclude system messages
-                .map(msg -> new ChatMessageDto(
+                .map(msg -> new ChatMessage(
                         msg.getRole().name(),
                         msg.getContent()
                 ))
@@ -168,4 +169,3 @@ private UserPriority getUserPriority(Long userId) {
         return userPriorityService.getUserPriority(userId);
     }
 }
-
diff --git a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/RestUserService.java b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/RestUserService.java
index 9b1405ea..512079e7 100644
--- a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/RestUserService.java
+++ b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/RestUserService.java
@@ -83,23 +83,21 @@ public static void applyFlagsByLevel(RestUser user, UserPriority level) {
         if (level == null) {
             return;
         }
-        switch (level) {
-            case ADMIN -> {
-                user.setIsAdmin(true);
-                user.setIsPremium(true);
-                user.setIsBlocked(false);
-            }
-            case VIP -> {
-                user.setIsAdmin(false);
-                user.setIsPremium(true);
-                user.setIsBlocked(false);
-            }
-            case REGULAR, BLOCKED -> {
-                user.setIsAdmin(false);
-                user.setIsPremium(false);
-                user.setIsBlocked(level == UserPriority.BLOCKED);
-            }
+        if (level == UserPriority.ADMIN) {
+            user.setIsAdmin(true);
+            user.setIsPremium(true);
+            user.setIsBlocked(false);
+            return;
         }
+        if (level == UserPriority.VIP) {
+            user.setIsAdmin(false);
+            user.setIsPremium(true);
+            user.setIsBlocked(false);
+            return;
+        }
+        user.setIsAdmin(false);
+        user.setIsPremium(false);
+        user.setIsBlocked(level == UserPriority.BLOCKED);
     }
 
     /**
@@ -186,4 +184,3 @@ public Optional<RestUser> findById(Long id) {
         return restUserRepository.findById(id);
     }
 }
-
diff --git a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/model/AdminAttachmentRef.java b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/model/AdminAttachmentRef.java
new file mode 100644
index 00000000..05320626
--- /dev/null
+++ b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/model/AdminAttachmentRef.java
@@ -0,0 +1,11 @@
+package io.github.ngirchev.opendaimon.rest.service.model;
+
+import java.time.OffsetDateTime;
+
+public record AdminAttachmentRef(
+        String storageKey,
+        String mimeType,
+        String filename,
+        OffsetDateTime expiresAt
+) {
+}
diff --git a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/model/AdminConversationSummary.java b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/model/AdminConversationSummary.java
new file mode 100644
index 00000000..18099ef5
--- /dev/null
+++ b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/model/AdminConversationSummary.java
@@ -0,0 +1,18 @@
+package io.github.ngirchev.opendaimon.rest.service.model;
+
+import java.time.OffsetDateTime;
+
+public record AdminConversationSummary(
+        Long id,
+        String threadKey,
+        String title,
+        String scopeKind,
+        Long scopeId,
+        Integer totalMessages,
+        Long totalTokens,
+        Boolean isActive,
+        OffsetDateTime lastActivityAt,
+        OffsetDateTime createdAt,
+        AdminUserSummary user
+) {
+}
diff --git a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/model/AdminMessageDetail.java b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/model/AdminMessageDetail.java
new file mode 100644
index 00000000..a87eb376
--- /dev/null
+++ b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/model/AdminMessageDetail.java
@@ -0,0 +1,26 @@
+package io.github.ngirchev.opendaimon.rest.service.model;
+
+import java.time.OffsetDateTime;
+import java.util.List;
+import java.util.Map;
+
+public record AdminMessageDetail(
+        Long id,
+        Long threadId,
+        Integer sequenceNumber,
+        String role,
+        String content,
+        String requestType,
+        String status,
+        String serviceName,
+        Integer tokenCount,
+        Integer processingTimeMs,
+        String errorMessage,
+        Long telegramMessageId,
+        OffsetDateTime createdAt,
+        List<AdminAttachmentRef> attachments,
+        Map<String, Object> metadata,
+        Map<String, Object> responseData,
+        AdminUserSummary user
+) {
+}
diff --git a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/model/AdminMessageSummary.java b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/model/AdminMessageSummary.java
new file mode 100644
index 00000000..106eafe0
--- /dev/null
+++ b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/model/AdminMessageSummary.java
@@ -0,0 +1,15 @@
+package io.github.ngirchev.opendaimon.rest.service.model;
+
+import java.time.OffsetDateTime;
+
+public record AdminMessageSummary(
+        Long id,
+        Integer sequenceNumber,
+        String role,
+        String requestType,
+        String status,
+        String contentPreview,
+        int attachmentCount,
+        OffsetDateTime createdAt
+) {
+}
diff --git a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/model/AdminPageResponse.java b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/model/AdminPageResponse.java
new file mode 100644
index 00000000..9a09b09f
--- /dev/null
+++ b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/model/AdminPageResponse.java
@@ -0,0 +1,23 @@
+package io.github.ngirchev.opendaimon.rest.service.model;
+
+import org.springframework.data.domain.Page;
+
+import java.util.List;
+
+public record AdminPageResponse<T>(
+        List<T> content,
+        int page,
+        int size,
+        long totalElements,
+        int totalPages
+) {
+    public static <T> AdminPageResponse<T> from(Page<T> page) {
+        return new AdminPageResponse<>(
+                page.getContent(),
+                page.getNumber(),
+                page.getSize(),
+                page.getTotalElements(),
+                page.getTotalPages()
+        );
+    }
+}
diff --git a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/model/AdminUserSummary.java b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/model/AdminUserSummary.java
new file mode 100644
index 00000000..d59d5121
--- /dev/null
+++ b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/model/AdminUserSummary.java
@@ -0,0 +1,13 @@
+package io.github.ngirchev.opendaimon.rest.service.model;
+
+public record AdminUserSummary(
+        Long id,
+        String userType,
+        String username,
+        String firstName,
+        String lastName,
+        String emailOrTelegramId,
+        Boolean isAdmin,
+        Boolean isBlocked
+) {
+}
diff --git a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/model/ChatMessage.java b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/model/ChatMessage.java
new file mode 100644
index 00000000..7edd0b3e
--- /dev/null
+++ b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/model/ChatMessage.java
@@ -0,0 +1,4 @@
+package io.github.ngirchev.opendaimon.rest.service.model;
+
+public record ChatMessage(String role, String content) {
+}
diff --git a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/model/ChatResponse.java b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/model/ChatResponse.java
new file mode 100644
index 00000000..fa5d9fa7
--- /dev/null
+++ b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/model/ChatResponse.java
@@ -0,0 +1,4 @@
+package io.github.ngirchev.opendaimon.rest.service.model;
+
+public record ChatResponse<T>(T message, String sessionId) {
+}
diff --git a/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/model/ChatSession.java b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/model/ChatSession.java
new file mode 100644
index 00000000..b4f4a35c
--- /dev/null
+++ b/opendaimon-rest/src/main/java/io/github/ngirchev/opendaimon/rest/service/model/ChatSession.java
@@ -0,0 +1,6 @@
+package io.github.ngirchev.opendaimon.rest.service.model;
+
+import java.time.OffsetDateTime;
+
+public record ChatSession(String sessionId, String name, OffsetDateTime createdAt) {
+}
diff --git a/opendaimon-rest/src/test/java/io/github/ngirchev/opendaimon/rest/arch/RestArchitectureTest.java b/opendaimon-rest/src/test/java/io/github/ngirchev/opendaimon/rest/arch/RestArchitectureTest.java
new file mode 100644
index 00000000..19617aa1
--- /dev/null
+++ b/opendaimon-rest/src/test/java/io/github/ngirchev/opendaimon/rest/arch/RestArchitectureTest.java
@@ -0,0 +1,103 @@
+package io.github.ngirchev.opendaimon.rest.arch;
+
+import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes;
+import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.methods;
+import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses;
+
+import com.tngtech.archunit.core.importer.ImportOption;
+import com.tngtech.archunit.junit.AnalyzeClasses;
+import com.tngtech.archunit.junit.ArchTest;
+import com.tngtech.archunit.lang.ArchRule;
+import org.springframework.boot.autoconfigure.AutoConfiguration;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.stereotype.Component;
+import org.springframework.stereotype.Repository;
+import org.springframework.stereotype.Service;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.ControllerAdvice;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+
+@AnalyzeClasses(
+        packages = "io.github.ngirchev.opendaimon.rest",
+        importOptions = {
+                ImportOption.DoNotIncludeTests.class,
+                ImportOption.DoNotIncludeJars.class
+        }
+)
+class RestArchitectureTest {
+
+    @ArchTest
+    static final ArchRule rest_uses_no_service_or_component_stereotypes =
+            noClasses()
+                    .should().beAnnotatedWith(Service.class)
+                    .orShould().beAnnotatedWith(Component.class)
+                    .because("rest exports Spring beans through explicit configuration.");
+
+    @ArchTest
+    static final ArchRule rest_uses_no_repository_classes =
+            noClasses()
+                    .that().areNotInterfaces()
+                    .should().beAnnotatedWith(Repository.class)
+                    .because("@Repository is only allowed on Spring Data repository interfaces.");
+
+    @ArchTest
+    static final ArchRule bean_methods_are_declared_only_in_config_packages =
+            methods()
+                    .that().areAnnotatedWith(Bean.class)
+                    .should().beDeclaredInClassesThat().resideInAPackage("..rest.config..")
+                    .because("rest beans must be exposed through explicit configuration classes.");
+
+    @ArchTest
+    static final ArchRule configuration_classes_are_declared_only_in_config_packages =
+            classes()
+                    .that().areAnnotatedWith(AutoConfiguration.class)
+                    .or().areAnnotatedWith(Configuration.class)
+                    .should().resideInAPackage("..rest.config..")
+                    .because("Spring configuration belongs in config packages.");
+
+    @ArchTest
+    static final ArchRule configuration_properties_are_declared_only_in_config_packages =
+            classes()
+                    .that().areAnnotatedWith(ConfigurationProperties.class)
+                    .should().resideInAPackage("..rest.config..")
+                    .andShould().haveSimpleNameEndingWith("Properties")
+                    .andShould().beAnnotatedWith(Validated.class)
+                    .because("rest configuration properties must stay validated in config packages.");
+
+    @ArchTest
+    static final ArchRule rest_controllers_are_declared_only_in_controller_packages =
+            classes()
+                    .that().areAnnotatedWith(RestController.class)
+                    .should().resideInAPackage("..rest.controller..")
+                    .because("HTTP endpoints belong in controller packages.");
+
+    @ArchTest
+    static final ArchRule rest_controller_advice_is_declared_only_in_exception_packages =
+            classes()
+                    .that().areAnnotatedWith(ControllerAdvice.class)
+                    .or().areAnnotatedWith(RestControllerAdvice.class)
+                    .should().resideInAPackage("..rest.exception..")
+                    .because("REST exception handling belongs in the exception package.");
+
+    @ArchTest
+    static final ArchRule repositories_are_accessed_only_from_service_config_or_repositories =
+            noClasses()
+                    .that().resideOutsideOfPackages(
+                            "..rest.config..",
+                            "..rest.repository..",
+                            "..rest.service..")
+                    .should().dependOnClassesThat().resideInAPackage("..rest.repository..")
+                    .because("repository access must stay behind services and explicit configuration.");
+
+    @ArchTest
+    static final ArchRule service_layer_does_not_depend_on_http_dtos_or_handlers =
+            noClasses()
+                    .that().resideInAPackage("..rest.service..")
+                    .should().dependOnClassesThat().resideInAnyPackage(
+                            "..rest.dto..",
+                            "..rest.handler..")
+                    .because("REST services expose internal models and must not depend on HTTP DTOs or handlers.");
+}
diff --git a/opendaimon-rest/src/test/java/io/github/ngirchev/opendaimon/rest/controller/SessionControllerContractTest.java b/opendaimon-rest/src/test/java/io/github/ngirchev/opendaimon/rest/controller/SessionControllerContractTest.java
index 7f854baa..b13169cd 100644
--- a/opendaimon-rest/src/test/java/io/github/ngirchev/opendaimon/rest/controller/SessionControllerContractTest.java
+++ b/opendaimon-rest/src/test/java/io/github/ngirchev/opendaimon/rest/controller/SessionControllerContractTest.java
@@ -6,21 +6,21 @@
 import io.github.ngirchev.opendaimon.common.service.MessageLocalizationService;
 import io.github.ngirchev.opendaimon.rest.RestTestConfiguration;
 import io.github.ngirchev.opendaimon.rest.config.AdminSecurityConfig;
-import io.github.ngirchev.opendaimon.rest.dto.ChatMessageDto;
+import io.github.ngirchev.opendaimon.rest.service.model.ChatMessage;
 import io.github.ngirchev.opendaimon.rest.dto.ChatRequestDto;
-import io.github.ngirchev.opendaimon.rest.dto.ChatResponseDto;
-import io.github.ngirchev.opendaimon.rest.dto.ChatSessionDto;
+import io.github.ngirchev.opendaimon.rest.service.model.ChatResponse;
+import io.github.ngirchev.opendaimon.rest.service.model.ChatSession;
 import io.github.ngirchev.opendaimon.rest.exception.RestExceptionHandler;
 import io.github.ngirchev.opendaimon.rest.exception.UnauthorizedException;
 import io.github.ngirchev.opendaimon.rest.model.RestUser;
 import io.github.ngirchev.opendaimon.rest.repository.RestUserRepository;
 import io.github.ngirchev.opendaimon.rest.service.ChatService;
 import io.github.ngirchev.opendaimon.rest.service.RestAuthorizationService;
+import jakarta.annotation.Resource;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
 import org.springframework.context.annotation.Import;
 import org.springframework.http.MediaType;
@@ -33,6 +33,7 @@
 import java.time.OffsetDateTime;
 import java.util.List;
 
+import static org.hamcrest.Matchers.equalTo;
 import static org.junit.jupiter.api.Assertions.*;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyString;
@@ -60,10 +61,10 @@ class SessionControllerContractTest {
     private static final String TEST_EMAIL = "user@test.com";
     private static final String SESSION_ID = "session-123";
 
-    @Autowired
+    @Resource
     private MockMvc mockMvc;
 
-    @Autowired
+    @Resource
     private ObjectMapper objectMapper;
 
     @MockitoBean
@@ -100,7 +101,7 @@ class PostNewChat {
         @DisplayName("returns 200 and JSON with message and sessionId when authorized")
         void whenAuthorized_returns200AndResponseDto() throws Exception {
             ChatRequestDto request = new ChatRequestDto("Hello", null, null, TEST_EMAIL);
-            ChatResponseDto<String> response = new ChatResponseDto<>("AI reply", SESSION_ID);
+            ChatResponse<String> response = new ChatResponse<>("AI reply", SESSION_ID);
 
             when(restAuthorizationService.authorize(eq(TEST_EMAIL), anyString())).thenReturn(restUser);
             doReturn(response).when(chatService).sendMessageToNewChat(eq("Hello"), eq(restUser), any(), eq(false));
@@ -110,8 +111,8 @@ void whenAuthorized_returns200AndResponseDto() throws Exception {
                             .content(toJson(request)))
                     .andExpect(status().isOk())
                     .andExpect(content().contentType(MediaType.APPLICATION_JSON))
-                    .andExpect(jsonPath("$.message").value("AI reply"))
-                    .andExpect(jsonPath("$.sessionId").value(SESSION_ID));
+                    .andExpect(jsonPath("$.message").value(equalTo("AI reply")))
+                    .andExpect(jsonPath("$.sessionId").value(equalTo(SESSION_ID)));
         }
 
         @Test
@@ -126,8 +127,8 @@ void whenNoEmail_returns401() throws Exception {
                     .andExpect(status().isUnauthorized())
                     .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                     .andExpect(jsonPath("$.message").exists())
-                    .andExpect(jsonPath("$.status").value(401))
-                    .andExpect(jsonPath("$.redirect").value("/login"));
+                    .andExpect(jsonPath("$.status").value(equalTo(401)))
+                    .andExpect(jsonPath("$.redirect").value(equalTo("/login")));
         }
 
         @Test
@@ -142,8 +143,8 @@ void whenAuthorizeThrows_returns401() throws Exception {
                             .accept(MediaType.APPLICATION_JSON)
                             .content(toJson(request)))
                     .andExpect(status().isUnauthorized())
-                    .andExpect(jsonPath("$.message").value("User not found"))
-                    .andExpect(jsonPath("$.status").value(401));
+                    .andExpect(jsonPath("$.message").value(equalTo("User not found")))
+                    .andExpect(jsonPath("$.status").value(equalTo(401)));
         }
     }
 
@@ -155,7 +156,7 @@ class PostExistingSession {
         @DisplayName("returns 200 and JSON with message and sessionId when authorized")
         void whenAuthorized_returns200AndResponseDto() throws Exception {
             ChatRequestDto request = new ChatRequestDto("Follow-up", null, null, TEST_EMAIL);
-            ChatResponseDto<String> response = new ChatResponseDto<>("AI reply", SESSION_ID);
+            ChatResponse<String> response = new ChatResponse<>("AI reply", SESSION_ID);
 
             when(restAuthorizationService.authorize(eq(TEST_EMAIL), anyString())).thenReturn(restUser);
             doReturn(response).when(chatService).sendMessage(eq(SESSION_ID), eq("Follow-up"), eq(restUser), any(), eq(false));
@@ -165,8 +166,8 @@ void whenAuthorized_returns200AndResponseDto() throws Exception {
                             .content(toJson(request)))
                     .andExpect(status().isOk())
                     .andExpect(content().contentType(MediaType.APPLICATION_JSON))
-                    .andExpect(jsonPath("$.message").value("AI reply"))
-                    .andExpect(jsonPath("$.sessionId").value(SESSION_ID));
+                    .andExpect(jsonPath("$.message").value(equalTo("AI reply")))
+                    .andExpect(jsonPath("$.sessionId").value(equalTo(SESSION_ID)));
         }
 
         @Test
@@ -189,9 +190,9 @@ class GetSessions {
         @Test
         @DisplayName("returns 200 and JSON array of sessions when authorized")
         void whenAuthorized_returns200AndSessionList() throws Exception {
-            List<ChatSessionDto> sessions = List.of(
-                    new ChatSessionDto("s1", "Chat 1", OffsetDateTime.now()),
-                    new ChatSessionDto("s2", "Chat 2", OffsetDateTime.now())
+            List<ChatSession> sessions = List.of(
+                    new ChatSession("s1", "Chat 1", OffsetDateTime.now()),
+                    new ChatSession("s2", "Chat 2", OffsetDateTime.now())
             );
             when(restAuthorizationService.authorize(eq(TEST_EMAIL), anyString())).thenReturn(restUser);
             when(chatService.getSessions(restUser)).thenReturn(sessions);
@@ -199,11 +200,11 @@ void whenAuthorized_returns200AndSessionList() throws Exception {
             mockMvc.perform(get(BASE_URL).param("email", TEST_EMAIL))
                     .andExpect(status().isOk())
                     .andExpect(content().contentType(MediaType.APPLICATION_JSON))
-                    .andExpect(jsonPath("$.length()").value(2))
-                    .andExpect(jsonPath("$[0].sessionId").value("s1"))
-                    .andExpect(jsonPath("$[0].name").value("Chat 1"))
+                    .andExpect(jsonPath("$.length()").value(equalTo(2)))
+                    .andExpect(jsonPath("$[0].sessionId").value(equalTo("s1")))
+                    .andExpect(jsonPath("$[0].name").value(equalTo("Chat 1")))
                     .andExpect(jsonPath("$[0].createdAt").exists())
-                    .andExpect(jsonPath("$[1].sessionId").value("s2"));
+                    .andExpect(jsonPath("$[1].sessionId").value(equalTo("s2")));
         }
 
         @Test
@@ -221,9 +222,9 @@ class GetSessionMessages {
         @Test
         @DisplayName("returns 200 and JSON with sessionId and messages when authorized")
         void whenAuthorized_returns200AndHistory() throws Exception {
-            List<ChatMessageDto> messages = List.of(
-                    new ChatMessageDto("USER", "Hello"),
-                    new ChatMessageDto("ASSISTANT", "Hi there")
+            List<ChatMessage> messages = List.of(
+                    new ChatMessage("USER", "Hello"),
+                    new ChatMessage("ASSISTANT", "Hi there")
             );
             when(restAuthorizationService.authorize(eq(TEST_EMAIL), anyString())).thenReturn(restUser);
             when(chatService.getChatHistory(SESSION_ID, restUser)).thenReturn(messages);
@@ -231,12 +232,12 @@ void whenAuthorized_returns200AndHistory() throws Exception {
             mockMvc.perform(get(BASE_URL + "/" + SESSION_ID + "/messages").param("email", TEST_EMAIL))
                     .andExpect(status().isOk())
                     .andExpect(content().contentType(MediaType.APPLICATION_JSON))
-                    .andExpect(jsonPath("$.sessionId").value(SESSION_ID))
-                    .andExpect(jsonPath("$.messages.length()").value(2))
-                    .andExpect(jsonPath("$.messages[0].role").value("USER"))
-                    .andExpect(jsonPath("$.messages[0].content").value("Hello"))
-                    .andExpect(jsonPath("$.messages[1].role").value("ASSISTANT"))
-                    .andExpect(jsonPath("$.messages[1].content").value("Hi there"));
+                    .andExpect(jsonPath("$.sessionId").value(equalTo(SESSION_ID)))
+                    .andExpect(jsonPath("$.messages.length()").value(equalTo(2)))
+                    .andExpect(jsonPath("$.messages[0].role").value(equalTo("USER")))
+                    .andExpect(jsonPath("$.messages[0].content").value(equalTo("Hello")))
+                    .andExpect(jsonPath("$.messages[1].role").value(equalTo("ASSISTANT")))
+                    .andExpect(jsonPath("$.messages[1].content").value(equalTo("Hi there")));
         }
 
         @Test
@@ -291,7 +292,7 @@ void whenJsonAccept_returns400Json() throws Exception {
                     .andExpect(status().isBadRequest())
                     .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                     .andExpect(jsonPath("$.message").exists())
-                    .andExpect(jsonPath("$.status").value(400));
+                    .andExpect(jsonPath("$.status").value(equalTo(400)));
         }
     }
 
@@ -315,7 +316,7 @@ void whenJsonAccept_returns403Json() throws Exception {
                     .andExpect(status().isForbidden())
                     .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                     .andExpect(jsonPath("$.message").exists())
-                    .andExpect(jsonPath("$.status").value(403));
+                    .andExpect(jsonPath("$.status").value(equalTo(403)));
         }
     }
 
@@ -328,7 +329,7 @@ class PostStreamNewChat {
         void whenAuthorized_returnsSseStream() throws Exception {
             ChatRequestDto request = new ChatRequestDto("Hello", null, null, TEST_EMAIL);
             Flux<String> flux = Flux.just("Hello", " ", "world");
-            ChatResponseDto<Flux<String>> response = new ChatResponseDto<>(flux, SESSION_ID);
+            ChatResponse<Flux<String>> response = new ChatResponse<>(flux, SESSION_ID);
 
             when(restAuthorizationService.authorize(eq(TEST_EMAIL), anyString())).thenReturn(restUser);
             doReturn(response).when(chatService).sendMessageToNewChat(eq("Hello"), eq(restUser), any(), eq(true));
@@ -375,7 +376,7 @@ class PostStreamExistingSession {
         void whenAuthorized_returnsSseStream() throws Exception {
             ChatRequestDto request = new ChatRequestDto("More", null, null, TEST_EMAIL);
             Flux<String> flux = Flux.just("Response");
-            ChatResponseDto<Flux<String>> response = new ChatResponseDto<>(flux, SESSION_ID);
+            ChatResponse<Flux<String>> response = new ChatResponse<>(flux, SESSION_ID);
 
             when(restAuthorizationService.authorize(eq(TEST_EMAIL), anyString())).thenReturn(restUser);
             doReturn(response).when(chatService).sendMessage(eq(SESSION_ID), eq("More"), eq(restUser), any(), eq(true));
diff --git a/opendaimon-rest/src/test/java/io/github/ngirchev/opendaimon/rest/handler/RestChatHandlerSupportTest.java b/opendaimon-rest/src/test/java/io/github/ngirchev/opendaimon/rest/handler/RestChatHandlerSupportTest.java
index d4f155d8..a3e02583 100644
--- a/opendaimon-rest/src/test/java/io/github/ngirchev/opendaimon/rest/handler/RestChatHandlerSupportTest.java
+++ b/opendaimon-rest/src/test/java/io/github/ngirchev/opendaimon/rest/handler/RestChatHandlerSupportTest.java
@@ -1,6 +1,5 @@
 package io.github.ngirchev.opendaimon.rest.handler;
 
-import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import io.github.ngirchev.opendaimon.common.SupportedLanguages;
 import io.github.ngirchev.opendaimon.common.ai.ModelCapabilities;
@@ -9,7 +8,8 @@
 import io.github.ngirchev.opendaimon.common.model.ConversationThread;
 import io.github.ngirchev.opendaimon.common.service.OpenDaimonMessageService;
 import io.github.ngirchev.opendaimon.common.service.MessageLocalizationService;
-import io.github.ngirchev.opendaimon.rest.dto.ChatRequestDto;
+import io.github.ngirchev.opendaimon.rest.command.RestChatCommand;
+import io.github.ngirchev.opendaimon.rest.command.RestChatCommandType;
 import io.github.ngirchev.opendaimon.rest.model.RestUser;
 import jakarta.servlet.http.HttpServletRequest;
 import org.junit.jupiter.api.BeforeEach;
@@ -58,14 +58,14 @@ class GetRequestLanguage {
         @Test
         void whenRequestHasLocale_returnsLanguageCode() {
             HttpServletRequest request = mockRequestWithLocale(Locale.ENGLISH);
-            RestChatCommand command = new RestChatCommand(new ChatRequestDto("hi", null, null, null), RestChatCommandType.MESSAGE, request, 1L);
+            RestChatCommand command = new RestChatCommand("hi", null, null, null, RestChatCommandType.MESSAGE, request, 1L);
 
             assertEquals("en", RestChatHandlerSupport.getRequestLanguage(command));
         }
 
         @Test
         void whenRequestNull_returnsDefaultLanguage() {
-            RestChatCommand command = new RestChatCommand(new ChatRequestDto("hi", null, null, null), RestChatCommandType.MESSAGE, null, 1L);
+            RestChatCommand command = new RestChatCommand("hi", null, null, null, RestChatCommandType.MESSAGE, null, 1L);
 
             assertEquals(SupportedLanguages.DEFAULT_LANGUAGE, RestChatHandlerSupport.getRequestLanguage(command));
         }
@@ -73,7 +73,7 @@ void whenRequestNull_returnsDefaultLanguage() {
         @Test
         void whenLocaleNull_returnsDefaultLanguage() {
             HttpServletRequest request = mockRequestWithLocale(null);
-            RestChatCommand command = new RestChatCommand(new ChatRequestDto("hi", null, null, null), RestChatCommandType.MESSAGE, request, 1L);
+            RestChatCommand command = new RestChatCommand("hi", null, null, null, RestChatCommandType.MESSAGE, request, 1L);
 
             assertEquals(SupportedLanguages.DEFAULT_LANGUAGE, RestChatHandlerSupport.getRequestLanguage(command));
         }
@@ -119,7 +119,7 @@ void containsModelErrorTypeErrorMessageAndTimestamp() {
     class SerializeToJson {
 
         @Test
-        void whenMapValid_returnsJsonString() throws JsonProcessingException {
+        void whenMapValid_returnsJsonString() throws Exception {
             Map<String, Object> map = Map.of("key", "value");
             when(objectMapper.writeValueAsString(map)).thenReturn("{\"key\":\"value\"}");
 
@@ -137,7 +137,7 @@ void whenMapEmpty_returnsNull() {
         }
 
         @Test
-        void whenWriteValueThrows_returnsNull() throws JsonProcessingException {
+        void whenWriteValueThrows_returnsNull() throws Exception {
             Map<String, Object> map = Map.of("x", "y");
             when(objectMapper.writeValueAsString(map)).thenThrow(new RuntimeException("serialization failed"));
 
@@ -150,9 +150,9 @@ void whenWriteValueThrows_returnsNull() throws JsonProcessingException {
     class HandleProcessingError {
 
         @Test
-        void whenUserMessageNotNull_savesAssistantErrorMessageAndReturnsRuntimeException() throws JsonProcessingException {
+        void whenUserMessageNotNull_savesAssistantErrorMessageAndReturnsRuntimeException() throws Exception {
             HttpServletRequest request = mockRequestWithLocale(Locale.ENGLISH);
-            RestChatCommand command = new RestChatCommand(new ChatRequestDto("hi", null, null, null), RestChatCommandType.MESSAGE, request, 1L);
+            RestChatCommand command = new RestChatCommand("hi", null, null, null, RestChatCommandType.MESSAGE, request, 1L);
             RestUser user = new RestUser();
             AssistantRole role = new AssistantRole();
             role.setContent("Role content");
@@ -172,7 +172,7 @@ void whenUserMessageNotNull_savesAssistantErrorMessageAndReturnsRuntimeException
 
         @Test
         void whenUserMessageNull_doesNotCallSaveAssistantErrorMessage() {
-            RestChatCommand command = new RestChatCommand(new ChatRequestDto("hi", null, null, null), RestChatCommandType.MESSAGE, null, 1L);
+            RestChatCommand command = new RestChatCommand("hi", null, null, null, RestChatCommandType.MESSAGE, null, 1L);
             when(messageLocalizationService.getMessage(eq("rest.error.processing"), eq(SupportedLanguages.DEFAULT_LANGUAGE), any())).thenReturn("Error");
 
             RuntimeException result = support.handleProcessingError(command, null, Set.of(), new RuntimeException("x"));
@@ -181,7 +181,7 @@ void whenUserMessageNull_doesNotCallSaveAssistantErrorMessage() {
         }
 
         @Test
-        void whenModelCapabilitiesEmpty_usesChatInMetadata() throws JsonProcessingException {
+        void whenModelCapabilitiesEmpty_usesChatInMetadata() throws Exception {
             when(objectMapper.writeValueAsString(any())).thenAnswer(inv -> {
                 @SuppressWarnings("unchecked")
                 Map<String, Object> m = inv.getArgument(0);
@@ -189,7 +189,7 @@ void whenModelCapabilitiesEmpty_usesChatInMetadata() throws JsonProcessingExcept
                 return "{}";
             });
             when(messageLocalizationService.getMessage(any(), any(), any())).thenReturn("Err");
-            RestChatCommand command = new RestChatCommand(new ChatRequestDto("h", null, null, null), RestChatCommandType.MESSAGE, null, 1L);
+            RestChatCommand command = new RestChatCommand("h", null, null, null, RestChatCommandType.MESSAGE, null, 1L);
 
             support.handleProcessingError(command, null, Set.of(), new IllegalStateException("x"));
         }
diff --git a/opendaimon-rest/src/test/java/io/github/ngirchev/opendaimon/rest/handler/RestChatMessageCommandHandlerTest.java b/opendaimon-rest/src/test/java/io/github/ngirchev/opendaimon/rest/handler/RestChatMessageCommandHandlerTest.java
index f358cd85..bcf4fe02 100644
--- a/opendaimon-rest/src/test/java/io/github/ngirchev/opendaimon/rest/handler/RestChatMessageCommandHandlerTest.java
+++ b/opendaimon-rest/src/test/java/io/github/ngirchev/opendaimon/rest/handler/RestChatMessageCommandHandlerTest.java
@@ -16,7 +16,8 @@
 import io.github.ngirchev.opendaimon.common.service.AIGateway;
 import io.github.ngirchev.opendaimon.common.service.OpenDaimonMessageService;
 import io.github.ngirchev.opendaimon.common.service.AIGatewayRegistry;
-import io.github.ngirchev.opendaimon.rest.dto.ChatRequestDto;
+import io.github.ngirchev.opendaimon.rest.command.RestChatCommand;
+import io.github.ngirchev.opendaimon.rest.command.RestChatCommandType;
 import io.github.ngirchev.opendaimon.rest.model.RestUser;
 import io.github.ngirchev.opendaimon.common.service.MessageLocalizationService;
 import io.github.ngirchev.opendaimon.rest.service.RestMessageService;
@@ -109,15 +110,13 @@ class CanHandle {
 
         @Test
         void whenRestChatCommandWithMessageType_returnsTrue() {
-            RestChatCommand command = new RestChatCommand(
-                    new ChatRequestDto("hi", null, null, null), RestChatCommandType.MESSAGE, request, 1L);
+            RestChatCommand command = new RestChatCommand("hi", null, null, null, RestChatCommandType.MESSAGE, request, 1L);
             assertTrue(handler.canHandle(command));
         }
 
         @Test
         void whenRestChatCommandWithStreamType_returnsFalse() {
-            RestChatCommand command = new RestChatCommand(
-                    new ChatRequestDto("hi", null, null, null), RestChatCommandType.STREAM, request, 1L);
+            RestChatCommand command = new RestChatCommand("hi", null, null, null, RestChatCommandType.STREAM, request, 1L);
             assertFalse(handler.canHandle(command));
         }
 
@@ -131,8 +130,7 @@ void whenCommandNotRestChatCommand_returnsFalse() {
 
         @Test
         void whenCommandTypeNull_returnsFalse() {
-            RestChatCommand command = new RestChatCommand(
-                    new ChatRequestDto("hi", null, null, null), null, request, 1L);
+            RestChatCommand command = new RestChatCommand("hi", null, null, null, null, request, 1L);
             assertFalse(handler.canHandle(command));
         }
     }
@@ -153,8 +151,7 @@ class Handle {
 
         @Test
         void whenSuccess_returnsResponseAndSavesAssistantMessage() {
-            RestChatCommand command = new RestChatCommand(
-                    new ChatRequestDto("Hello", null, null, "user@test.com"), RestChatCommandType.MESSAGE, request, 1L);
+            RestChatCommand command = new RestChatCommand("Hello", null, null, "user@test.com", RestChatCommandType.MESSAGE, request, 1L);
             when(restUserService.findById(1L)).thenReturn(Optional.of(user));
             when(restMessageService.saveUserMessage(eq(user), eq("Hello"), eq(RequestType.TEXT), eq(null), eq(request)))
                     .thenReturn(userMessage);
@@ -172,8 +169,7 @@ void whenSuccess_returnsResponseAndSavesAssistantMessage() {
 
         @Test
         void whenResponseContentEmpty_savesErrorAndThrowsRuntimeException() {
-            RestChatCommand command = new RestChatCommand(
-                    new ChatRequestDto("Hi", null, null, null), RestChatCommandType.MESSAGE, request, 1L);
+            RestChatCommand command = new RestChatCommand("Hi", null, null, null, RestChatCommandType.MESSAGE, request, 1L);
             when(restUserService.findById(1L)).thenReturn(Optional.of(user));
             when(restMessageService.saveUserMessage(any(), any(), any(), any(), any())).thenReturn(userMessage);
             when(aiRequestPipeline.prepareCommand(eq(command), any())).thenReturn(aiCommand);
@@ -187,8 +183,7 @@ void whenResponseContentEmpty_savesErrorAndThrowsRuntimeException() {
 
         @Test
         void whenUserNotFound_throwsRuntimeException() {
-            RestChatCommand command = new RestChatCommand(
-                    new ChatRequestDto("Hi", null, null, null), RestChatCommandType.MESSAGE, request, 99L);
+            RestChatCommand command = new RestChatCommand("Hi", null, null, null, RestChatCommandType.MESSAGE, request, 99L);
             when(restUserService.findById(99L)).thenReturn(Optional.empty());
             when(support.getMessageLocalizationService()).thenReturn(messageLocalizationService);
             when(messageLocalizationService.getMessage(eq("rest.user.not.found"), any(), eq(99L))).thenReturn("User not found");
@@ -198,8 +193,7 @@ void whenUserNotFound_throwsRuntimeException() {
 
         @Test
         void whenAccessDeniedException_thrownAsIs() {
-            RestChatCommand command = new RestChatCommand(
-                    new ChatRequestDto("Hi", null, null, null), RestChatCommandType.MESSAGE, request, 1L);
+            RestChatCommand command = new RestChatCommand("Hi", null, null, null, RestChatCommandType.MESSAGE, request, 1L);
             when(restUserService.findById(1L)).thenReturn(Optional.of(user));
             when(restMessageService.saveUserMessage(any(), any(), any(), any(), any())).thenReturn(userMessage);
             when(aiRequestPipeline.prepareCommand(eq(command), any())).thenReturn(aiCommand);
@@ -212,8 +206,7 @@ void whenAccessDeniedException_thrownAsIs() {
 
         @Test
         void whenUserMessageTooLongException_thrownAsIs() {
-            RestChatCommand command = new RestChatCommand(
-                    new ChatRequestDto("Hi", null, null, null), RestChatCommandType.MESSAGE, request, 1L);
+            RestChatCommand command = new RestChatCommand("Hi", null, null, null, RestChatCommandType.MESSAGE, request, 1L);
             when(restUserService.findById(1L)).thenReturn(Optional.of(user));
             when(restMessageService.saveUserMessage(any(), any(), any(), any(), any())).thenThrow(new UserMessageTooLongException("too long"));
 
@@ -223,8 +216,7 @@ void whenUserMessageTooLongException_thrownAsIs() {
 
         @Test
         void whenGenericException_callsSupportHandleProcessingErrorAndRethrows() {
-            RestChatCommand command = new RestChatCommand(
-                    new ChatRequestDto("Hi", null, null, null), RestChatCommandType.MESSAGE, request, 1L);
+            RestChatCommand command = new RestChatCommand("Hi", null, null, null, RestChatCommandType.MESSAGE, request, 1L);
             when(restUserService.findById(1L)).thenReturn(Optional.of(user));
             when(restMessageService.saveUserMessage(any(), any(), any(), any(), any())).thenReturn(userMessage);
             when(aiRequestPipeline.prepareCommand(eq(command), any())).thenReturn(aiCommand);
diff --git a/opendaimon-rest/src/test/java/io/github/ngirchev/opendaimon/rest/handler/RestChatStreamMessageCommandHandlerTest.java b/opendaimon-rest/src/test/java/io/github/ngirchev/opendaimon/rest/handler/RestChatStreamMessageCommandHandlerTest.java
index 10e853c2..5417b208 100644
--- a/opendaimon-rest/src/test/java/io/github/ngirchev/opendaimon/rest/handler/RestChatStreamMessageCommandHandlerTest.java
+++ b/opendaimon-rest/src/test/java/io/github/ngirchev/opendaimon/rest/handler/RestChatStreamMessageCommandHandlerTest.java
@@ -17,7 +17,8 @@
 import io.github.ngirchev.opendaimon.common.service.OpenDaimonMessageService;
 import io.github.ngirchev.opendaimon.common.service.AIGatewayRegistry;
 import io.github.ngirchev.opendaimon.common.service.MessageLocalizationService;
-import io.github.ngirchev.opendaimon.rest.dto.ChatRequestDto;
+import io.github.ngirchev.opendaimon.rest.command.RestChatCommand;
+import io.github.ngirchev.opendaimon.rest.command.RestChatCommandType;
 import io.github.ngirchev.opendaimon.rest.model.RestUser;
 import io.github.ngirchev.opendaimon.rest.service.RestMessageService;
 import io.github.ngirchev.opendaimon.rest.service.RestUserService;
@@ -109,15 +110,13 @@ class CanHandle {
 
         @Test
         void whenRestChatCommandWithStreamType_returnsTrue() {
-            RestChatCommand command = new RestChatCommand(
-                    new ChatRequestDto("hi", null, null, null), RestChatCommandType.STREAM, request, 1L);
+            RestChatCommand command = new RestChatCommand("hi", null, null, null, RestChatCommandType.STREAM, request, 1L);
             assertTrue(handler.canHandle(command));
         }
 
         @Test
         void whenRestChatCommandWithMessageType_returnsFalse() {
-            RestChatCommand command = new RestChatCommand(
-                    new ChatRequestDto("hi", null, null, null), RestChatCommandType.MESSAGE, request, 1L);
+            RestChatCommand command = new RestChatCommand("hi", null, null, null, RestChatCommandType.MESSAGE, request, 1L);
             assertFalse(handler.canHandle(command));
         }
 
@@ -131,8 +130,7 @@ void whenCommandNotRestChatCommand_returnsFalse() {
 
         @Test
         void whenCommandTypeNull_returnsFalse() {
-            RestChatCommand command = new RestChatCommand(
-                    new ChatRequestDto("hi", null, null, null), null, request, 1L);
+            RestChatCommand command = new RestChatCommand("hi", null, null, null, null, request, 1L);
             assertFalse(handler.canHandle(command));
         }
     }
@@ -153,8 +151,7 @@ class Handle {
 
         @Test
         void whenSuccess_returnsFluxAndSavesAssistantMessageOnComplete() {
-            RestChatCommand command = new RestChatCommand(
-                    new ChatRequestDto("Hello", null, null, "user@test.com"), RestChatCommandType.STREAM, request, 1L);
+            RestChatCommand command = new RestChatCommand("Hello", null, null, "user@test.com", RestChatCommandType.STREAM, request, 1L);
             when(restUserService.findById(1L)).thenReturn(Optional.of(user));
             when(restMessageService.saveUserMessage(eq(user), eq("Hello"), eq(RequestType.TEXT), eq(null), eq(request)))
                     .thenReturn(userMessage);
@@ -177,8 +174,7 @@ void whenSuccess_returnsFluxAndSavesAssistantMessageOnComplete() {
 
         @Test
         void whenResponseNotSpringAIStream_handleProcessingErrorReturnsIllegalStateAndRethrows() {
-            RestChatCommand command = new RestChatCommand(
-                    new ChatRequestDto("Hi", null, null, null), RestChatCommandType.STREAM, request, 1L);
+            RestChatCommand command = new RestChatCommand("Hi", null, null, null, RestChatCommandType.STREAM, request, 1L);
             when(restUserService.findById(1L)).thenReturn(Optional.of(user));
             when(restMessageService.saveUserMessage(any(), any(), any(), any(), any())).thenReturn(userMessage);
             when(aiRequestPipeline.prepareCommand(eq(command), any())).thenReturn(aiCommand);
@@ -195,8 +191,7 @@ void whenResponseNotSpringAIStream_handleProcessingErrorReturnsIllegalStateAndRe
 
         @Test
         void whenUserNotFound_throwsRuntimeException() {
-            RestChatCommand command = new RestChatCommand(
-                    new ChatRequestDto("Hi", null, null, null), RestChatCommandType.STREAM, request, 99L);
+            RestChatCommand command = new RestChatCommand("Hi", null, null, null, RestChatCommandType.STREAM, request, 99L);
             when(restUserService.findById(99L)).thenReturn(Optional.empty());
             when(support.getMessageLocalizationService()).thenReturn(messageLocalizationService);
             when(messageLocalizationService.getMessage(eq("rest.user.not.found"), any(), eq(99L))).thenReturn("User not found");
@@ -206,8 +201,7 @@ void whenUserNotFound_throwsRuntimeException() {
 
         @Test
         void whenAccessDeniedException_thrownAsIs() {
-            RestChatCommand command = new RestChatCommand(
-                    new ChatRequestDto("Hi", null, null, null), RestChatCommandType.STREAM, request, 1L);
+            RestChatCommand command = new RestChatCommand("Hi", null, null, null, RestChatCommandType.STREAM, request, 1L);
             when(restUserService.findById(1L)).thenReturn(Optional.of(user));
             when(restMessageService.saveUserMessage(any(), any(), any(), any(), any())).thenReturn(userMessage);
             when(aiRequestPipeline.prepareCommand(eq(command), any())).thenReturn(aiCommand);
@@ -220,8 +214,7 @@ void whenAccessDeniedException_thrownAsIs() {
 
         @Test
         void whenUserMessageTooLongException_thrownAsIs() {
-            RestChatCommand command = new RestChatCommand(
-                    new ChatRequestDto("Hi", null, null, null), RestChatCommandType.STREAM, request, 1L);
+            RestChatCommand command = new RestChatCommand("Hi", null, null, null, RestChatCommandType.STREAM, request, 1L);
             when(restUserService.findById(1L)).thenReturn(Optional.of(user));
             when(restMessageService.saveUserMessage(any(), any(), any(), any(), any())).thenThrow(new UserMessageTooLongException("too long"));
 
@@ -231,8 +224,7 @@ void whenUserMessageTooLongException_thrownAsIs() {
 
         @Test
         void whenGenericException_callsSupportHandleProcessingErrorAndRethrows() {
-            RestChatCommand command = new RestChatCommand(
-                    new ChatRequestDto("Hi", null, null, null), RestChatCommandType.STREAM, request, 1L);
+            RestChatCommand command = new RestChatCommand("Hi", null, null, null, RestChatCommandType.STREAM, request, 1L);
             when(restUserService.findById(1L)).thenReturn(Optional.of(user));
             when(restMessageService.saveUserMessage(any(), any(), any(), any(), any())).thenReturn(userMessage);
             when(aiRequestPipeline.prepareCommand(eq(command), any())).thenReturn(aiCommand);
diff --git a/opendaimon-rest/src/test/java/io/github/ngirchev/opendaimon/rest/service/AdminAttachmentServiceTest.java b/opendaimon-rest/src/test/java/io/github/ngirchev/opendaimon/rest/service/AdminAttachmentServiceTest.java
index 0a92a767..dba963d2 100644
--- a/opendaimon-rest/src/test/java/io/github/ngirchev/opendaimon/rest/service/AdminAttachmentServiceTest.java
+++ b/opendaimon-rest/src/test/java/io/github/ngirchev/opendaimon/rest/service/AdminAttachmentServiceTest.java
@@ -101,6 +101,16 @@ void shouldReturnEmptyWhenStorageLookupFails() {
         assertThat(resolved).isEmpty();
     }
 
+    @Test
+    void shouldReturnEmptyWhenStorageIsDisabled() {
+        service = new AdminAttachmentService(messageRepository, null);
+
+        Optional<AdminAttachmentService.ResolvedAttachment> resolved = service.resolve(42L, "abc123");
+
+        assertThat(resolved).isEmpty();
+        verify(messageRepository, never()).findById(org.mockito.ArgumentMatchers.anyLong());
+    }
+
     @Test
     void shouldFallbackDefaultMimeWhenMissing() {
         OpenDaimonMessage message = messageWithAttachments(List.of(
diff --git a/opendaimon-rest/src/test/java/io/github/ngirchev/opendaimon/rest/service/AdminQueryServiceTest.java b/opendaimon-rest/src/test/java/io/github/ngirchev/opendaimon/rest/service/AdminQueryServiceTest.java
index 99c8c107..397179b4 100644
--- a/opendaimon-rest/src/test/java/io/github/ngirchev/opendaimon/rest/service/AdminQueryServiceTest.java
+++ b/opendaimon-rest/src/test/java/io/github/ngirchev/opendaimon/rest/service/AdminQueryServiceTest.java
@@ -7,10 +7,10 @@
 import io.github.ngirchev.opendaimon.common.model.ResponseStatus;
 import io.github.ngirchev.opendaimon.common.model.ThreadScopeKind;
 import io.github.ngirchev.opendaimon.common.repository.OpenDaimonMessageRepository;
-import io.github.ngirchev.opendaimon.rest.dto.admin.ConversationSummaryDto;
-import io.github.ngirchev.opendaimon.rest.dto.admin.MessageDetailDto;
-import io.github.ngirchev.opendaimon.rest.dto.admin.MessageSummaryDto;
-import io.github.ngirchev.opendaimon.rest.dto.admin.PageResponseDto;
+import io.github.ngirchev.opendaimon.rest.service.model.AdminConversationSummary;
+import io.github.ngirchev.opendaimon.rest.service.model.AdminMessageDetail;
+import io.github.ngirchev.opendaimon.rest.service.model.AdminMessageSummary;
+import io.github.ngirchev.opendaimon.rest.service.model.AdminPageResponse;
 import io.github.ngirchev.opendaimon.rest.exception.UnauthorizedException;
 import io.github.ngirchev.opendaimon.rest.model.RestUser;
 import io.github.ngirchev.opendaimon.rest.repository.AdminConversationRepository;
@@ -64,10 +64,10 @@ void shouldMapConversationSummaryWithRestUser() {
         Page<ConversationThread> page = new PageImpl<>(List.of(t), pageable, 1);
         when(adminConversationRepository.findAllWithFilters(any(), any(), any(), eq(pageable))).thenReturn(page);
 
-        PageResponseDto<ConversationSummaryDto> result = service.listConversations(null, null, null, pageable);
+        AdminPageResponse<AdminConversationSummary> result = service.listConversations(null, null, null, pageable);
 
         assertThat(result.content()).hasSize(1);
-        ConversationSummaryDto dto = result.content().get(0);
+        AdminConversationSummary dto = result.content().get(0);
         assertThat(dto.id()).isEqualTo(10L);
         assertThat(dto.threadKey()).isEqualTo("key-10");
         assertThat(dto.scopeKind()).isEqualTo(ThreadScopeKind.USER.name());
@@ -97,7 +97,7 @@ void shouldReturnMessagesOrderedByRepository() {
         when(adminConversationRepository.findByIdWithUser(10L)).thenReturn(Optional.of(t));
         when(messageRepository.findByThreadOrderBySequenceNumberAsc(t)).thenReturn(List.of(m1, m2));
 
-        List<MessageSummaryDto> result = service.listMessages(10L);
+        List<AdminMessageSummary> result = service.listMessages(10L);
 
         assertThat(result).hasSize(2);
         assertThat(result.get(0).role()).isEqualTo("USER");
@@ -116,7 +116,7 @@ void shouldTruncateContentPreview() {
         when(adminConversationRepository.findByIdWithUser(10L)).thenReturn(Optional.of(t));
         when(messageRepository.findByThreadOrderBySequenceNumberAsc(t)).thenReturn(List.of(m));
 
-        List<MessageSummaryDto> result = service.listMessages(10L);
+        List<AdminMessageSummary> result = service.listMessages(10L);
 
         assertThat(result).hasSize(1);
         assertThat(result.get(0).contentPreview()).hasSize(201);
@@ -141,7 +141,7 @@ void shouldMapMessageDetailAttachments() {
         m.setMetadata(Map.of("client_ip", "127.0.0.1"));
         when(messageRepository.findById(5L)).thenReturn(Optional.of(m));
 
-        MessageDetailDto dto = service.getMessage(5L);
+        AdminMessageDetail dto = service.getMessage(5L);
 
         assertThat(dto.id()).isEqualTo(5L);
         assertThat(dto.threadId()).isEqualTo(10L);
diff --git a/opendaimon-rest/src/test/java/io/github/ngirchev/opendaimon/rest/service/ChatServiceTest.java b/opendaimon-rest/src/test/java/io/github/ngirchev/opendaimon/rest/service/ChatServiceTest.java
index 91f462d8..196e8e49 100644
--- a/opendaimon-rest/src/test/java/io/github/ngirchev/opendaimon/rest/service/ChatServiceTest.java
+++ b/opendaimon-rest/src/test/java/io/github/ngirchev/opendaimon/rest/service/ChatServiceTest.java
@@ -9,9 +9,9 @@
 import io.github.ngirchev.opendaimon.common.repository.ConversationThreadRepository;
 import io.github.ngirchev.opendaimon.common.service.CommandSyncService;
 import io.github.ngirchev.opendaimon.common.service.ConversationThreadService;
-import io.github.ngirchev.opendaimon.rest.dto.ChatMessageDto;
-import io.github.ngirchev.opendaimon.rest.dto.ChatResponseDto;
-import io.github.ngirchev.opendaimon.rest.dto.ChatSessionDto;
+import io.github.ngirchev.opendaimon.rest.service.model.ChatMessage;
+import io.github.ngirchev.opendaimon.rest.service.model.ChatResponse;
+import io.github.ngirchev.opendaimon.rest.service.model.ChatSession;
 import io.github.ngirchev.opendaimon.rest.exception.UnauthorizedException;
 import io.github.ngirchev.opendaimon.rest.model.RestUser;
 import jakarta.servlet.http.HttpServletRequest;
@@ -82,7 +82,7 @@ void whenNoActiveThread_createsNewThreadAndSendsMessage() {
             when(conversationThreadService.createNewThread(currentUser)).thenReturn(thread);
             when(commandSyncService.syncAndHandle(any(), any())).thenReturn("AI response");
 
-            ChatResponseDto<String> result = service.sendMessageToNewChat("Hello", currentUser, request, false);
+            ChatResponse<String> result = service.sendMessageToNewChat("Hello", currentUser, request, false);
 
             assertEquals("AI response", result.message());
             assertEquals("session-123", result.sessionId());
@@ -98,7 +98,7 @@ void whenActiveThreadExists_closesItThenCreatesNewAndSends() {
             when(conversationThreadService.createNewThread(currentUser)).thenReturn(thread);
             when(commandSyncService.syncAndHandle(any(), any())).thenReturn("OK");
 
-            ChatResponseDto<String> result = service.sendMessageToNewChat("Hi", currentUser, request, false);
+            ChatResponse<String> result = service.sendMessageToNewChat("Hi", currentUser, request, false);
 
             assertEquals("OK", result.message());
             verify(conversationThreadService).closeThread(activeThread);
@@ -115,7 +115,7 @@ void whenSessionBelongsToUser_activatesThreadAndSends() {
             when(threadRepository.findByThreadKey("session-123")).thenReturn(Optional.of(thread));
             when(commandSyncService.syncAndHandle(any(), any())).thenReturn("Reply");
 
-            ChatResponseDto<String> result = service.sendMessage("session-123", "Hi", currentUser, request, false);
+            ChatResponse<String> result = service.sendMessage("session-123", "Hi", currentUser, request, false);
 
             assertEquals("Reply", result.message());
             assertEquals("session-123", result.sessionId());
@@ -153,7 +153,7 @@ void mapsThreadsToChatSessionDtos() {
             thread.setTitle(null);
             when(threadRepository.findByUserOrderByLastActivityAtDesc(currentUser)).thenReturn(List.of(thread));
 
-            List<ChatSessionDto> result = service.getSessions(currentUser);
+            List<ChatSession> result = service.getSessions(currentUser);
 
             assertEquals(1, result.size());
             assertEquals("session-123", result.get(0).sessionId());
@@ -165,7 +165,7 @@ void mapsThreadsToChatSessionDtos() {
         void whenThreadHasTitle_usesIt() {
             when(threadRepository.findByUserOrderByLastActivityAtDesc(currentUser)).thenReturn(List.of(thread));
 
-            List<ChatSessionDto> result = service.getSessions(currentUser);
+            List<ChatSession> result = service.getSessions(currentUser);
 
             assertEquals("Test", result.get(0).name());
         }
@@ -190,7 +190,7 @@ void whenSessionBelongsToUser_returnsMessagesExcludingSystem() {
             when(messageRepository.findByThreadOrderBySequenceNumberAsc(thread))
                     .thenReturn(List.of(systemMsg, userMsg, assistantMsg));
 
-            List<ChatMessageDto> result = service.getChatHistory("session-123", currentUser);
+            List<ChatMessage> result = service.getChatHistory("session-123", currentUser);
 
             assertEquals(2, result.size());
             assertEquals("USER", result.get(0).role());
diff --git a/opendaimon-spring-ai/SPRING_AI_MODULE.md b/opendaimon-spring-ai/SPRING_AI_MODULE.md
index 0964adb6..3ff997a8 100644
--- a/opendaimon-spring-ai/SPRING_AI_MODULE.md
+++ b/opendaimon-spring-ai/SPRING_AI_MODULE.md
@@ -101,6 +101,8 @@ If `springAiProperties.mock = true` → return mock response immediately, no mod
 
 Web tools (`WebTools` / Serper) are attached to the prompt when:
 - command requests `WEB` in **required** (`modelCapabilities`) or **optional** (`optionalCapabilities`).
+- `web_search` is disabled when `open-daimon.ai.spring-ai.serper.api.key` is blank;
+  in that case it returns an empty search result without calling Serper.
 
 ---
 
@@ -541,6 +543,12 @@ never sees an orphan "⚠️ reached iteration limit" status line with no body t
 the warn message ever shows up in `logs/`, it flags a bug in the
 `handleMaxIterations` fallback chain rather than being normal steady state.
 
+Final-answer cleanup strips model reasoning before both delivery and chat-memory
+persistence. The sanitizer handles provider metadata, `<think>...</think>` blocks,
+or plaintext `THINK:`/`Thought:` prefixes. If a plaintext reasoning prefix has no
+clear answer boundary, the cleaned answer is treated as empty so the retry/fallback
+path runs instead of saving or sending reasoning as assistant text.
+
 ### WebClient codec — `webToolsWebClient` bean
 
 Built-in agent tools that fetch arbitrary third-party pages/APIs (`WebTools`,
diff --git a/opendaimon-spring-ai/pom.xml b/opendaimon-spring-ai/pom.xml
index 85c186d0..8bc20f96 100644
--- a/opendaimon-spring-ai/pom.xml
+++ b/opendaimon-spring-ai/pom.xml
@@ -27,8 +27,6 @@
 
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
-        <jsoup.version>1.17.2</jsoup.version>
-        <pdfbox.version>3.0.5</pdfbox.version>
     </properties>
 
     <dependencies>
@@ -38,99 +36,271 @@
             <artifactId>opendaimon-common</artifactId>
             <version>${project.version}</version>
         </dependency>
+        <dependency>
+            <groupId>io.github.ngirchev</groupId>
+            <artifactId>fsm</artifactId>
+        </dependency>
 
-        <!-- Spring Boot -->
+        <!-- Spring Framework leaves (declare what you use) -->
         <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-web</artifactId>
-            <exclusions>
-                <exclusion>
-                    <groupId>org.springframework.boot</groupId>
-                    <artifactId>spring-boot-starter-logging</artifactId>
-                </exclusion>
-            </exclusions>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-core</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-beans</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-context</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-tx</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-web</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-webflux</artifactId>
         </dependency>
 
+        <!-- Spring Boot core -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot</artifactId>
+        </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-validation</artifactId>
+            <artifactId>spring-boot-autoconfigure</artifactId>
         </dependency>
 
         <!-- Spring AI -->
         <dependency>
             <groupId>org.springframework.ai</groupId>
-            <artifactId>spring-ai-starter-model-ollama</artifactId>
+            <artifactId>spring-ai-model</artifactId>
         </dependency>
         <dependency>
             <groupId>org.springframework.ai</groupId>
-            <artifactId>spring-ai-starter-model-openai</artifactId>
+            <artifactId>spring-ai-client-chat</artifactId>
         </dependency>
         <dependency>
             <groupId>org.springframework.ai</groupId>
-            <artifactId>spring-ai-starter-model-chat-memory</artifactId>
+            <artifactId>spring-ai-commons</artifactId>
         </dependency>
         <dependency>
             <groupId>org.springframework.ai</groupId>
-            <artifactId>spring-ai-starter-model-chat-memory-repository-jdbc</artifactId>
+            <artifactId>spring-ai-ollama</artifactId>
         </dependency>
-        <!-- PDF Document Reader for RAG -->
+        <dependency>
+            <groupId>org.springframework.ai</groupId>
+            <artifactId>spring-ai-openai</artifactId>
+        </dependency>
+        <!-- Provider/chat-client autoconfig from Spring AI starters, kept explicit for starter hygiene -->
+        <dependency>
+            <groupId>org.springframework.ai</groupId>
+            <artifactId>spring-ai-autoconfigure-model-openai</artifactId>
+            <scope>runtime</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.ai</groupId>
+            <artifactId>spring-ai-autoconfigure-model-ollama</artifactId>
+            <scope>runtime</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.ai</groupId>
+            <artifactId>spring-ai-autoconfigure-model-chat-client</artifactId>
+            <scope>runtime</scope>
+        </dependency>
+        <!-- Chat memory autoconfig + JDBC repository (runtime-only autoconfig glue) -->
+        <dependency>
+            <groupId>org.springframework.ai</groupId>
+            <artifactId>spring-ai-autoconfigure-model-chat-memory</artifactId>
+            <scope>runtime</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.ai</groupId>
+            <artifactId>spring-ai-autoconfigure-model-chat-memory-repository-jdbc</artifactId>
+            <scope>runtime</scope>
+        </dependency>
+        <!-- Document readers used directly in DocumentProcessingService -->
         <dependency>
             <groupId>org.springframework.ai</groupId>
             <artifactId>spring-ai-pdf-document-reader</artifactId>
         </dependency>
-        <!-- Tika Document Reader for DOCX and other formats -->
         <dependency>
             <groupId>org.springframework.ai</groupId>
             <artifactId>spring-ai-tika-document-reader</artifactId>
+            <exclusions>
+                <exclusion>
+                    <groupId>commons-logging</groupId>
+                    <artifactId>commons-logging</artifactId>
+                </exclusion>
+            </exclusions>
         </dependency>
-        <!-- Vector Store for RAG (SimpleVectorStore) -->
         <dependency>
             <groupId>org.springframework.ai</groupId>
             <artifactId>spring-ai-vector-store</artifactId>
         </dependency>
 
-        <!-- PDFBox for spring-ai-pdf-document-reader (marked as optional in Spring AI) -->
+        <!-- Reactor (Mono/Flux + Netty HTTP transport) -->
+        <dependency>
+            <groupId>io.projectreactor</groupId>
+            <artifactId>reactor-core</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.reactivestreams</groupId>
+            <artifactId>reactive-streams</artifactId>
+        </dependency>
+        <!-- SpringAIAutoConfig configures Netty resolver/handler explicitly -->
+        <dependency>
+            <groupId>io.netty</groupId>
+            <artifactId>netty-resolver</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.netty</groupId>
+            <artifactId>netty-handler</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.projectreactor.netty</groupId>
+            <artifactId>reactor-netty-http</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.projectreactor.netty</groupId>
+            <artifactId>reactor-netty-core</artifactId>
+        </dependency>
+
+        <!-- AOP (OpenRouterModelRotationAspect) -->
+        <dependency>
+            <groupId>org.aspectj</groupId>
+            <artifactId>aspectjweaver</artifactId>
+        </dependency>
+
+        <!-- Validation -->
+        <dependency>
+            <groupId>jakarta.validation</groupId>
+            <artifactId>jakarta.validation-api</artifactId>
+        </dependency>
+
+        <!-- Tika core (used directly in PdfTextDetector / SpringDocumentPipelineActions) -->
+        <dependency>
+            <groupId>org.apache.tika</groupId>
+            <artifactId>tika-core</artifactId>
+        </dependency>
+
+        <!-- PDFBox (used directly in SpringDocumentPipelineActions for RandomAccessRead) -->
         <dependency>
             <groupId>org.apache.pdfbox</groupId>
             <artifactId>pdfbox</artifactId>
-            <version>${pdfbox.version}</version>
         </dependency>
         <dependency>
             <groupId>org.apache.pdfbox</groupId>
             <artifactId>pdfbox-io</artifactId>
-            <version>${pdfbox.version}</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>commons-logging</groupId>
+                    <artifactId>commons-logging</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+
+        <!-- Persistence metadata from opendaimon-common public entity types is read during compile -->
+        <dependency>
+            <groupId>jakarta.persistence</groupId>
+            <artifactId>jakarta.persistence-api</artifactId>
+        </dependency>
+
+        <!-- Database / Flyway core for module migrations -->
+        <dependency>
+            <groupId>org.flywaydb</groupId>
+            <artifactId>flyway-core</artifactId>
+        </dependency>
+
+        <!-- Annotations -->
+        <dependency>
+            <groupId>jakarta.annotation</groupId>
+            <artifactId>jakarta.annotation-api</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.jetbrains</groupId>
+            <artifactId>annotations</artifactId>
+        </dependency>
+
+        <!-- Logging -->
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
         </dependency>
 
+        <!-- Lombok: compile-only annotation processor -->
         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>
+            <scope>provided</scope>
             <optional>true</optional>
         </dependency>
 
-        <!-- WebClient -->
+        <!-- Jackson -->
         <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-webflux</artifactId>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-core</artifactId>
         </dependency>
 
-        <!-- Other utilities -->
+        <!-- Jsoup HTML parser -->
         <dependency>
             <groupId>org.jsoup</groupId>
             <artifactId>jsoup</artifactId>
-            <version>${jsoup.version}</version>
         </dependency>
 
-        <!-- Caffeine: in-memory cache for UrlLivenessChecker (version managed in root pom) -->
+        <!-- Caffeine: in-memory cache for UrlLivenessChecker -->
         <dependency>
             <groupId>com.github.ben-manes.caffeine</groupId>
             <artifactId>caffeine</artifactId>
-            <version>${caffeine.version}</version>
         </dependency>
 
         <!-- Test -->
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-test</artifactId>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-test</artifactId>
+            <artifactId>spring-boot-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.tngtech.archunit</groupId>
+            <artifactId>archunit</artifactId>
+            <version>${archunit.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.tngtech.archunit</groupId>
+            <artifactId>archunit-junit5-api</artifactId>
+            <version>${archunit.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.tngtech.archunit</groupId>
+            <artifactId>archunit-junit5-engine</artifactId>
+            <version>${archunit.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
             <scope>test</scope>
         </dependency>
         <dependency>
@@ -139,8 +309,13 @@
             <scope>test</scope>
         </dependency>
         <dependency>
-            <groupId>com.h2database</groupId>
-            <artifactId>h2</artifactId>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.squareup.okhttp3</groupId>
+            <artifactId>okhttp</artifactId>
             <scope>test</scope>
         </dependency>
         <dependency>
@@ -149,4 +324,54 @@
             <scope>test</scope>
         </dependency>
     </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-dependency-plugin</artifactId>
+                <configuration>
+                    <ignoredUnusedDeclaredDependencies>
+                        <!-- ArchUnit JUnit engine is discovered by JUnit Platform at runtime;
+                             no test class imports it directly. -->
+                        <ignored>com.tngtech.archunit:archunit-junit5-engine</ignored>
+                        <!-- pdfbox-io: required for compile (Loader.loadPDF overloads
+                             reference RandomAccessRead) even though no source imports it
+                             directly. Remove this ignore only if the Loader API surface
+                             stops requiring pdfbox-io types. -->
+                        <ignored>org.apache.pdfbox:pdfbox-io</ignored>
+                        <!-- Spring Boot discovers these auto-configurations through
+                             META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports.
+                             They provide provider ChatModel, ChatClient, and ChatMemory runtime
+                             beans for consumers of this starter-style module, so source analysis
+                             cannot see the usage. -->
+                        <ignored>org.springframework.ai:spring-ai-autoconfigure-model-openai</ignored>
+                        <ignored>org.springframework.ai:spring-ai-autoconfigure-model-ollama</ignored>
+                        <ignored>org.springframework.ai:spring-ai-autoconfigure-model-chat-client</ignored>
+                        <ignored>org.springframework.ai:spring-ai-autoconfigure-model-chat-memory</ignored>
+                        <ignored>org.springframework.ai:spring-ai-autoconfigure-model-chat-memory-repository-jdbc</ignored>
+                    </ignoredUnusedDeclaredDependencies>
+                    <ignoredNonTestScopedDependencies>
+                        <!-- Required on the main compile classpath to resolve jakarta.persistence
+                             enum constants present in opendaimon-common entity annotations. -->
+                        <ignored>jakarta.persistence:jakarta.persistence-api</ignored>
+                    </ignoredNonTestScopedDependencies>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-enforcer-plugin</artifactId>
+                <configuration>
+                    <rules>
+                        <bannedDependencies>
+                            <searchTransitive>true</searchTransitive>
+                            <excludes>
+                                <exclude>org.springframework.boot:spring-boot-starter*</exclude>
+                            </excludes>
+                        </bannedDependencies>
+                    </rules>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
 </project>
diff --git a/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/agent/AgentTextSanitizer.java b/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/agent/AgentTextSanitizer.java
index a23ffd61..ed4ddd5c 100644
--- a/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/agent/AgentTextSanitizer.java
+++ b/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/agent/AgentTextSanitizer.java
@@ -17,7 +17,8 @@
  * <p>Two related families of markup are handled:
  * <ul>
  *   <li>{@code <think>…</think>} reasoning blocks — extracted for the
- *       reasoning stream, then removed from the answer text.</li>
+ *       reasoning stream, then removed from the answer text. Plaintext
+ *       {@code THINK:}/{@code Thought:} prefixes are treated the same way.</li>
  *   <li>{@code <tool_call>…</tool_call>} and its loose fallback inner tags
  *       ({@code <name>}, {@code <arg_key>}, {@code <arg_value>}, bare tool
  *       names on their own line) — stripped unconditionally because they are
@@ -56,6 +57,15 @@ final class AgentTextSanitizer {
     /** Matches a bare tool-like name on its own line (e.g. {@code http_get}, {@code web_search}). */
     private static final Pattern BARE_TOOL_NAME_PATTERN =
             Pattern.compile("(?m)^\\s*\\w+_\\w+\\s*$");
+    /** Matches plaintext reasoning prefixes emitted by some models instead of tags/metadata. */
+    private static final Pattern PLAINTEXT_THINK_PREFIX_PATTERN =
+            Pattern.compile("(?is)^\\s*(?:THINK|Thought)\\s*:\\s*");
+    /** Common model-authored boundary between plaintext reasoning and the answer. */
+    private static final Pattern PLAINTEXT_FINAL_MARKER_PATTERN =
+            Pattern.compile("(?im)^\\s*(?:FINAL(?:_ANSWER)?|Answer|Response)\\s*:\\s*");
+    /** Blank line boundary between plaintext reasoning and the visible answer. */
+    private static final Pattern BLANK_LINE_PATTERN =
+            Pattern.compile("\\R\\s*\\R");
 
     private AgentTextSanitizer() {
         throw new AssertionError("static utility, do not instantiate");
@@ -64,11 +74,12 @@ private AgentTextSanitizer() {
     /**
      * Attempts to extract reasoning/thinking content from the LLM response.
      *
-     * <p>Two sources are checked:
+     * <p>Sources are checked in priority order:
      * <ol>
      *   <li>Generation metadata key "thinking" (Spring AI Ollama 1.1+ with think=true)</li>
      *   <li>Generation metadata key "reasoningContent" (OpenRouter/Anthropic)</li>
      *   <li>{@code <think>...</think>} tags in text output (older Ollama or custom models)</li>
+     *   <li>Plaintext {@code THINK:}/{@code Thought:} prefix blocks</li>
      * </ol>
      *
      * @return reasoning text, or null if not available
@@ -94,9 +105,11 @@ static String extractReasoning(ChatResponse response) {
             var output = response.getResult().getOutput();
             if (output != null && output.getText() != null) {
                 String rawText = output.getText();
-                if (rawText.contains("<think>")) {
-                    log.info("AgentTextSanitizer.extractReasoning: found <think> tags, textLength={}", rawText.length());
-                    return extractThinkTags(rawText);
+                String extracted = extractThinkTags(rawText);
+                if (extracted != null) {
+                    log.info("AgentTextSanitizer.extractReasoning: found reasoning markup, textLength={}",
+                            rawText.length());
+                    return extracted;
                 }
             }
         } catch (Exception e) {
@@ -106,8 +119,9 @@ static String extractReasoning(ChatResponse response) {
     }
 
     /**
-     * Extracts content from {@code <think>...</think>} tags (Ollama thinking mode).
-     * Returns the thinking text, or null if no tags found.
+     * Extracts content from {@code <think>...</think>} tags or plaintext
+     * {@code THINK:}/{@code Thought:} prefixes.
+     * Returns the thinking text, or null if no reasoning marker is found.
      */
     static String extractThinkTags(String text) {
         if (text == null) {
@@ -116,7 +130,7 @@ static String extractThinkTags(String text) {
         int start = text.indexOf("<think>");
         int end = text.indexOf("</think>");
         if (start < 0 || end < 0 || end <= start) {
-            return null;
+            return extractPlaintextThinkBlock(text);
         }
         String thinking = text.substring(start + "<think>".length(), end).trim();
         return thinking.isEmpty() ? null : thinking;
@@ -132,6 +146,9 @@ static String extractThinkTags(String text) {
      *   <li>Close without open: drops from start of text up to and including {@code </think>}.
      *       The open tag was lost (stream corruption, upstream sanitizer, or partial tag emit);
      *       text ahead of the orphan close is reasoning that must not leak to the user.</li>
+     *   <li>Plaintext {@code THINK:}/{@code Thought:} prefix: drops the reasoning block.
+     *       If no answer boundary can be found, returns an empty string so the caller can
+     *       handle it as an empty response instead of leaking reasoning.</li>
      * </ul>
      *
      * <p>Diverges from {@link StreamingAnswerFilter} on the orphan-close case: the
@@ -146,7 +163,7 @@ static String stripThinkTags(String text) {
         int start = text.indexOf("<think>");
         int end = text.indexOf("</think>");
         if (start < 0 && end < 0) {
-            return text;
+            return stripPlaintextThinkPrefix(text);
         }
         if (start < 0) {
             return text.substring(end + "</think>".length()).trim();
@@ -157,6 +174,46 @@ static String stripThinkTags(String text) {
         return (text.substring(0, start) + text.substring(end + "</think>".length())).trim();
     }
 
+    private static String extractPlaintextThinkBlock(String text) {
+        var prefix = PLAINTEXT_THINK_PREFIX_PATTERN.matcher(text);
+        if (!prefix.find()) {
+            return null;
+        }
+        int contentStart = prefix.end();
+        Boundary boundary = plaintextAnswerBoundary(text, contentStart);
+        String reasoning = boundary != null
+                ? text.substring(contentStart, boundary.reasoningEnd())
+                : text.substring(contentStart);
+        reasoning = reasoning.trim();
+        return reasoning.isEmpty() ? null : reasoning;
+    }
+
+    private static String stripPlaintextThinkPrefix(String text) {
+        var prefix = PLAINTEXT_THINK_PREFIX_PATTERN.matcher(text);
+        if (!prefix.find()) {
+            return text;
+        }
+        Boundary boundary = plaintextAnswerBoundary(text, prefix.end());
+        if (boundary == null) {
+            return "";
+        }
+        return text.substring(boundary.answerStart()).trim();
+    }
+
+    private static Boundary plaintextAnswerBoundary(String text, int searchFrom) {
+        var marker = PLAINTEXT_FINAL_MARKER_PATTERN.matcher(text);
+        if (marker.find(searchFrom)) {
+            return new Boundary(marker.start(), marker.end());
+        }
+        var blankLine = BLANK_LINE_PATTERN.matcher(text);
+        if (blankLine.find(searchFrom)) {
+            return new Boundary(blankLine.start(), blankLine.end());
+        }
+        return null;
+    }
+
+    private record Boundary(int reasoningEnd, int answerStart) {}
+
     /**
      * Strips raw XML tool call markup that some models emit in text responses
      * instead of using the structured function calling API.
diff --git a/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/agent/SpringAgentLoopActions.java b/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/agent/SpringAgentLoopActions.java
index 74b736ad..ce18b90d 100644
--- a/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/agent/SpringAgentLoopActions.java
+++ b/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/agent/SpringAgentLoopActions.java
@@ -260,7 +260,7 @@ public void think(AgentContext ctx) {
                         ctx.setCurrentTextResponse(text);
                         log.info("Agent think: final answer, length={}", text.length());
                         log.debug("Agent think: final answer text:\n{}", text);
-                        messages.add(output);
+                        messages.add(new AssistantMessage(text));
                     }
                 }
             }
diff --git a/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/agent/AgentAutoConfig.java b/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/config/AgentAutoConfig.java
similarity index 91%
rename from opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/agent/AgentAutoConfig.java
rename to opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/config/AgentAutoConfig.java
index 9205bbad..73a4ae67 100644
--- a/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/agent/AgentAutoConfig.java
+++ b/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/config/AgentAutoConfig.java
@@ -1,9 +1,16 @@
-package io.github.ngirchev.opendaimon.ai.springai.agent;
+package io.github.ngirchev.opendaimon.ai.springai.config;
 
 import io.github.ngirchev.fsm.impl.extended.ExDomainFsm;
+import io.github.ngirchev.opendaimon.ai.springai.agent.DefaultAgentOrchestrator;
+import io.github.ngirchev.opendaimon.ai.springai.agent.DelegatingAgentChatModel;
+import io.github.ngirchev.opendaimon.ai.springai.agent.PersistingAgentOrchestrator;
+import io.github.ngirchev.opendaimon.ai.springai.agent.PlanAndExecuteAgentExecutor;
+import io.github.ngirchev.opendaimon.ai.springai.agent.ReActAgentExecutor;
+import io.github.ngirchev.opendaimon.ai.springai.agent.SimpleChainExecutor;
+import io.github.ngirchev.opendaimon.ai.springai.agent.SpringAgentLoopActions;
+import io.github.ngirchev.opendaimon.ai.springai.agent.StrategyDelegatingAgentExecutor;
 import io.github.ngirchev.opendaimon.bulkhead.service.PriorityRequestExecutor;
 import io.github.ngirchev.opendaimon.common.config.FeatureToggle;
-import io.github.ngirchev.opendaimon.ai.springai.config.SpringAIAutoConfig;
 import io.github.ngirchev.opendaimon.ai.springai.retry.SpringAIModelRegistry;
 import io.github.ngirchev.opendaimon.ai.springai.tool.HttpApiTool;
 import io.github.ngirchev.opendaimon.ai.springai.tool.UrlLivenessChecker;
diff --git a/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/agent/AgentProperties.java b/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/config/AgentProperties.java
similarity index 91%
rename from opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/agent/AgentProperties.java
rename to opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/config/AgentProperties.java
index afa33a6b..fe05538c 100644
--- a/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/agent/AgentProperties.java
+++ b/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/config/AgentProperties.java
@@ -1,5 +1,6 @@
-package io.github.ngirchev.opendaimon.ai.springai.agent;
+package io.github.ngirchev.opendaimon.ai.springai.config;
 
+import io.github.ngirchev.opendaimon.ai.springai.agent.SpringAgentLoopActions;
 import jakarta.validation.constraints.Min;
 import jakarta.validation.constraints.NotNull;
 import lombok.Getter;
diff --git a/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/retry/OpenRouterModelsProperties.java b/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/config/OpenRouterModelsProperties.java
similarity index 99%
rename from opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/retry/OpenRouterModelsProperties.java
rename to opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/config/OpenRouterModelsProperties.java
index 1840945f..b7e25ed0 100644
--- a/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/retry/OpenRouterModelsProperties.java
+++ b/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/config/OpenRouterModelsProperties.java
@@ -1,4 +1,4 @@
-package io.github.ngirchev.opendaimon.ai.springai.retry;
+package io.github.ngirchev.opendaimon.ai.springai.config;
 
 import jakarta.validation.Valid;
 import jakarta.validation.constraints.AssertTrue;
diff --git a/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/config/SpringAIAutoConfig.java b/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/config/SpringAIAutoConfig.java
index 5d02ff02..39160881 100644
--- a/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/config/SpringAIAutoConfig.java
+++ b/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/config/SpringAIAutoConfig.java
@@ -66,15 +66,14 @@
 import org.springframework.context.support.GenericApplicationContext;
 
 import java.util.List;
-import io.github.ngirchev.opendaimon.common.repository.OpenDaimonMessageRepository;
-import io.github.ngirchev.opendaimon.common.repository.ConversationThreadRepository;
 import io.github.ngirchev.opendaimon.ai.springai.retry.OpenRouterFreeModelResolver;
 import io.github.ngirchev.opendaimon.ai.springai.retry.OpenRouterModelsApiClient;
-import io.github.ngirchev.opendaimon.ai.springai.retry.OpenRouterModelsProperties;
 import io.github.ngirchev.opendaimon.ai.springai.retry.OpenRouterModelStatsRecorder;
 import io.github.ngirchev.opendaimon.ai.springai.retry.metrics.OpenRouterStreamMetricsTracker;
 import io.github.ngirchev.opendaimon.common.ai.ModelDescriptionCache;
 import io.github.ngirchev.opendaimon.common.service.AIGatewayRegistry;
+import io.github.ngirchev.opendaimon.common.service.ConversationThreadService;
+import io.github.ngirchev.opendaimon.common.service.OpenDaimonMessageService;
 import io.github.ngirchev.opendaimon.common.service.SummarizationService;
 
 @Slf4j
@@ -508,16 +507,16 @@ public UrlLivenessChecker urlLivenessChecker(
     @DependsOn("springAiFlyway")
     public ChatMemory chatMemoryOnPostgresDb(
             ChatMemoryRepository chatMemoryRepository,
-            ConversationThreadRepository conversationThreadRepository,
-            OpenDaimonMessageRepository messageRepository,
+            ConversationThreadService conversationThreadService,
+            OpenDaimonMessageService messageService,
             SummarizationService summarizationService,
             org.springframework.context.ApplicationEventPublisher eventPublisher,
             CoreCommonProperties coreCommonProperties) {
 
         return new SummarizingChatMemory(
                 chatMemoryRepository,
-                conversationThreadRepository,
-                messageRepository,
+                conversationThreadService,
+                messageService,
                 summarizationService,
                 eventPublisher,
                 coreCommonProperties.getSummarization().getMessageWindowSize(),
diff --git a/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/config/SpringAIProperties.java b/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/config/SpringAIProperties.java
index 065a50ad..ce7e30d2 100644
--- a/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/config/SpringAIProperties.java
+++ b/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/config/SpringAIProperties.java
@@ -28,8 +28,6 @@ public class SpringAIProperties {
      */
     private OpenRouterApp openrouterApp = new OpenRouterApp();
 
-    private HttpLogs httpLogs = new HttpLogs();
-    
     private Serper serper = new Serper();
 
     private Models models = new Models();
@@ -116,7 +114,6 @@ public static class Serper {
         @Getter
         @Setter
         public static class Api {
-            @NotBlank(message = "API key for Serper cannot be blank")
             private String key;
             
             @NotBlank(message = "Serper API URL cannot be blank")
@@ -131,16 +128,6 @@ public static class Models {
         private List<SpringAIModelConfig> list = new ArrayList<>();
     }
 
-    @Getter
-    @Setter
-    public static class HttpLogs {
-        /**
-         * Log call stack of "who made the AI HTTP request" (once at startup).
-         * Disabled by default as it looks like an exception in logs and is noisy.
-         */
-        private Boolean callsiteStacktraceEnabled = false;
-    }
-    
     private Timeouts timeouts = new Timeouts();
     
     @Getter
diff --git a/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/memory/SummarizingChatMemory.java b/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/memory/SummarizingChatMemory.java
index 18a92ba1..4ca6f5e5 100644
--- a/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/memory/SummarizingChatMemory.java
+++ b/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/memory/SummarizingChatMemory.java
@@ -15,8 +15,8 @@
 import io.github.ngirchev.opendaimon.common.model.ConversationThread;
 import io.github.ngirchev.opendaimon.common.model.MessageRole;
 import io.github.ngirchev.opendaimon.common.model.OpenDaimonMessage;
-import io.github.ngirchev.opendaimon.common.repository.OpenDaimonMessageRepository;
-import io.github.ngirchev.opendaimon.common.repository.ConversationThreadRepository;
+import io.github.ngirchev.opendaimon.common.service.ConversationThreadService;
+import io.github.ngirchev.opendaimon.common.service.OpenDaimonMessageService;
 import io.github.ngirchev.opendaimon.common.service.SummarizationService;
 
 import java.util.ArrayList;
@@ -39,8 +39,8 @@
 public class SummarizingChatMemory implements ChatMemory {
 
     private final MessageWindowChatMemory delegate; // MessageWindowChatMemory
-    private final ConversationThreadRepository conversationThreadRepository;
-    private final OpenDaimonMessageRepository messageRepository;
+    private final ConversationThreadService conversationThreadService;
+    private final OpenDaimonMessageService messageService;
     private final SummarizationService summarizationService;
     private final ApplicationEventPublisher eventPublisher;
     private final Integer maxMessages; // Max messages from MessageWindowChatMemory
@@ -64,14 +64,14 @@ public class SummarizingChatMemory implements ChatMemory {
 
     public SummarizingChatMemory(
             ChatMemoryRepository chatMemoryRepository,
-            ConversationThreadRepository conversationThreadRepository,
-            OpenDaimonMessageRepository messageRepository,
+            ConversationThreadService conversationThreadService,
+            OpenDaimonMessageService messageService,
             SummarizationService summarizationService,
             ApplicationEventPublisher eventPublisher,
             Integer maxMessages,
             Integer maxWindowTokens) {
-        this.conversationThreadRepository = conversationThreadRepository;
-        this.messageRepository = messageRepository;
+        this.conversationThreadService = conversationThreadService;
+        this.messageService = messageService;
         this.summarizationService = summarizationService;
         this.eventPublisher = eventPublisher;
         this.maxMessages = maxMessages;
@@ -117,7 +117,7 @@ public List<Message> get(@NonNull String conversationId) {
         boolean tokenLimitReached = false;
 
         if (!messageLimitReached && maxWindowTokens != null) {
-            Optional<ConversationThread> threadOpt = conversationThreadRepository.findByThreadKey(conversationId);
+            Optional<ConversationThread> threadOpt = conversationThreadService.findByThreadKey(conversationId);
             tokenLimitReached = threadOpt
                 .map(t -> t.getTotalTokens() != null && t.getTotalTokens() >= maxWindowTokens)
                 .orElse(false);
@@ -170,7 +170,7 @@ public void add(@NonNull String conversationId, @NonNull List<Message> messages)
     private List<Message> restoreHistoryFromPrimaryStore(@NonNull String conversationId) {
         try {
             Optional<ConversationThread> threadOpt =
-                    conversationThreadRepository.findByThreadKey(conversationId);
+                    conversationThreadService.findByThreadKey(conversationId);
             if (threadOpt.isEmpty()) {
                 return List.of();
             }
@@ -184,7 +184,7 @@ private List<Message> restoreHistoryFromPrimaryStore(@NonNull String conversatio
             Integer messagesAtLastSummarization = thread.getMessagesAtLastSummarization();
             int minSequenceNumber = messagesAtLastSummarization != null ? messagesAtLastSummarization : 0;
 
-            List<OpenDaimonMessage> postSummaryMessages = messageRepository
+            List<OpenDaimonMessage> postSummaryMessages = messageService
                     .findByThreadAndSequenceNumberGreaterThanOrderBySequenceNumberAsc(thread, minSequenceNumber);
 
             // Drop the trailing in-flight USER row: TelegramMessageHandlerActions.saveMessage
@@ -235,7 +235,7 @@ private List<Message> restoreHistoryFromPrimaryStore(@NonNull String conversatio
      */
     private boolean performSummarizationAndUpdateChatMemory(@NonNull String conversationId) {
         try {
-            Optional<ConversationThread> threadOpt = conversationThreadRepository.findByThreadKey(conversationId);
+            Optional<ConversationThread> threadOpt = conversationThreadService.findByThreadKey(conversationId);
 
             if (threadOpt.isEmpty()) {
                 log.debug("Thread not found for conversationId {}, skipping summarization", conversationId);
@@ -251,7 +251,7 @@ private boolean performSummarizationAndUpdateChatMemory(@NonNull String conversa
             Integer messagesAtLastSummarization = thread.getMessagesAtLastSummarization();
             int minSequenceNumber = messagesAtLastSummarization != null ? messagesAtLastSummarization : 0;
 
-            List<OpenDaimonMessage> allMessages = new ArrayList<>(messageRepository
+            List<OpenDaimonMessage> allMessages = new ArrayList<>(messageService
                 .findByThreadAndSequenceNumberGreaterThanOrderBySequenceNumberAsc(thread, minSequenceNumber));
 
             if (allMessages.size() < 2) {
@@ -271,7 +271,7 @@ private boolean performSummarizationAndUpdateChatMemory(@NonNull String conversa
             summarizationService.summarizeThread(thread, toSummarize);
 
             // Refresh thread from DB after summarization
-            thread = conversationThreadRepository.findByThreadKey(conversationId)
+            thread = conversationThreadService.findByThreadKey(conversationId)
                 .orElseThrow(() -> new RuntimeException("Thread not found after summarization"));
 
             // Rebuild ChatMemory atomically so that any concurrent get() on the same
diff --git a/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/retry/OpenRouterFreeModelResolver.java b/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/retry/OpenRouterFreeModelResolver.java
index 6e55b4f9..b944c07e 100644
--- a/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/retry/OpenRouterFreeModelResolver.java
+++ b/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/retry/OpenRouterFreeModelResolver.java
@@ -1,5 +1,6 @@
 package io.github.ngirchev.opendaimon.ai.springai.retry;
 
+import io.github.ngirchev.opendaimon.ai.springai.config.OpenRouterModelsProperties;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import io.github.ngirchev.opendaimon.common.ai.ModelCapabilities;
diff --git a/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/retry/SpringAIModelRegistry.java b/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/retry/SpringAIModelRegistry.java
index 03544630..6a6ed16b 100644
--- a/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/retry/SpringAIModelRegistry.java
+++ b/opendaimon-spring-ai/src/main/java/io/github/ngirchev/opendaimon/ai/springai/retry/SpringAIModelRegistry.java
@@ -1,5 +1,6 @@
 package io.github.ngirchev.opendaimon.ai.springai.retry;
 
+import io.github.ngirchev.opendaimon.ai.springai.config.OpenRouterModelsProperties;
 import com.fasterxml.jackson.databind.JsonNode;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.util.StringUtils;
diff --git a/opendaimon-spring-ai/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports b/opendaimon-spring-ai/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
index d6e8d7f2..62b11162 100644
--- a/opendaimon-spring-ai/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
+++ b/opendaimon-spring-ai/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
@@ -1,3 +1,3 @@
 io.github.ngirchev.opendaimon.ai.springai.config.SpringAIAutoConfig
 io.github.ngirchev.opendaimon.ai.springai.config.RAGAutoConfig
-io.github.ngirchev.opendaimon.ai.springai.agent.AgentAutoConfig
\ No newline at end of file
+io.github.ngirchev.opendaimon.ai.springai.config.AgentAutoConfig
\ No newline at end of file
diff --git a/opendaimon-spring-ai/src/test/java/io/github/ngirchev/opendaimon/ai/springai/agent/AgentTextSanitizerThinkTagsTest.java b/opendaimon-spring-ai/src/test/java/io/github/ngirchev/opendaimon/ai/springai/agent/AgentTextSanitizerThinkTagsTest.java
index 123b884d..5511c134 100644
--- a/opendaimon-spring-ai/src/test/java/io/github/ngirchev/opendaimon/ai/springai/agent/AgentTextSanitizerThinkTagsTest.java
+++ b/opendaimon-spring-ai/src/test/java/io/github/ngirchev/opendaimon/ai/springai/agent/AgentTextSanitizerThinkTagsTest.java
@@ -18,6 +18,13 @@ void shouldReturnNullWhenNoThinkTags() {
         assertThat(AgentTextSanitizer.extractThinkTags("Just a regular answer")).isNull();
     }
 
+    @Test
+    void shouldExtractPlaintextThinkPrefixBeforeBlankLine() {
+        String text = "THINK: I should answer from the previous context.\n\nI already answered above.";
+        assertThat(AgentTextSanitizer.extractThinkTags(text))
+                .isEqualTo("I should answer from the previous context.");
+    }
+
     @Test
     void shouldReturnNullForNullInput() {
         assertThat(AgentTextSanitizer.extractThinkTags(null)).isNull();
@@ -46,6 +53,26 @@ void shouldReturnTextUnchangedWhenNoThinkTags() {
                 .isEqualTo("Just a regular answer");
     }
 
+    @Test
+    void shouldStripPlaintextThinkPrefixBeforeBlankLine() {
+        String text = "THINK: I should answer from the previous context.\n\nI already answered above.";
+        assertThat(AgentTextSanitizer.stripThinkTags(text))
+                .isEqualTo("I already answered above.");
+    }
+
+    @Test
+    void shouldStripPlaintextThoughtPrefixBeforeAnswerMarker() {
+        String text = "Thought: Need to be concise.\nAnswer: The answer is visible.";
+        assertThat(AgentTextSanitizer.stripThinkTags(text))
+                .isEqualTo("The answer is visible.");
+    }
+
+    @Test
+    void shouldReturnEmptyForPlaintextThinkPrefixWithoutAnswerBoundary() {
+        String text = "THINK: I should now present the answer but have not separated it";
+        assertThat(AgentTextSanitizer.stripThinkTags(text)).isEmpty();
+    }
+
     @Test
     void shouldReturnNullForNullStripInput() {
         assertThat(AgentTextSanitizer.stripThinkTags(null)).isNull();
diff --git a/opendaimon-spring-ai/src/test/java/io/github/ngirchev/opendaimon/ai/springai/agent/SpringAgentLoopActionsStreamingTest.java b/opendaimon-spring-ai/src/test/java/io/github/ngirchev/opendaimon/ai/springai/agent/SpringAgentLoopActionsStreamingTest.java
index 04de2e11..4cde354e 100644
--- a/opendaimon-spring-ai/src/test/java/io/github/ngirchev/opendaimon/ai/springai/agent/SpringAgentLoopActionsStreamingTest.java
+++ b/opendaimon-spring-ai/src/test/java/io/github/ngirchev/opendaimon/ai/springai/agent/SpringAgentLoopActionsStreamingTest.java
@@ -177,6 +177,23 @@ void shouldPreserveNonThinkContentWhenSnapshotStreamContainsEmbeddedThinkTag() {
         assertThat(joined).doesNotContain("reasoning");
     }
 
+    @Test
+    void shouldStripPlaintextThinkPrefixFromFallbackFinalAnswer() {
+        when(chatModel.stream(any(Prompt.class)))
+                .thenThrow(new RuntimeException("stream unavailable"));
+        when(chatModel.call(any(Prompt.class))).thenReturn(chunk(
+                "THINK: I should answer from prior context.\n\nI already answered above."));
+
+        actions.think(ctx);
+
+        assertThat(ctx.getCurrentTextResponse()).isEqualTo("I already answered above.");
+        assertThat(ctx.getCurrentTextResponse()).doesNotContain("THINK:");
+        assertThat(events)
+                .filteredOn(e -> e.type() == EventType.THINKING)
+                .extracting(AgentStreamEvent::content)
+                .anySatisfy(content -> assertThat(content).contains("prior context"));
+    }
+
     @Test
     @SuppressWarnings("unchecked")
     void shouldRouteFallbackCallThroughPriorityRequestExecutor() throws Exception {
diff --git a/opendaimon-spring-ai/src/test/java/io/github/ngirchev/opendaimon/ai/springai/arch/SpringAIArchitectureTest.java b/opendaimon-spring-ai/src/test/java/io/github/ngirchev/opendaimon/ai/springai/arch/SpringAIArchitectureTest.java
new file mode 100644
index 00000000..121c77b0
--- /dev/null
+++ b/opendaimon-spring-ai/src/test/java/io/github/ngirchev/opendaimon/ai/springai/arch/SpringAIArchitectureTest.java
@@ -0,0 +1,116 @@
+package io.github.ngirchev.opendaimon.ai.springai.arch;
+
+import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes;
+import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.methods;
+import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses;
+import static com.tngtech.archunit.library.dependencies.SlicesRuleDefinition.slices;
+
+import com.tngtech.archunit.core.domain.JavaClass;
+import com.tngtech.archunit.core.importer.ImportOption;
+import com.tngtech.archunit.junit.AnalyzeClasses;
+import com.tngtech.archunit.junit.ArchTest;
+import com.tngtech.archunit.lang.ArchRule;
+import com.tngtech.archunit.library.dependencies.SliceAssignment;
+import com.tngtech.archunit.library.dependencies.SliceIdentifier;
+import org.springframework.boot.autoconfigure.AutoConfiguration;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.stereotype.Component;
+import org.springframework.stereotype.Repository;
+import org.springframework.stereotype.Service;
+import org.springframework.validation.annotation.Validated;
+
+@AnalyzeClasses(
+        packages = "io.github.ngirchev.opendaimon.ai.springai",
+        importOptions = {
+                ImportOption.DoNotIncludeTests.class,
+                ImportOption.DoNotIncludeJars.class
+        }
+)
+class SpringAIArchitectureTest {
+
+    private static final SliceAssignment SPRING_AI_RUNTIME_SLICES = new SliceAssignment() {
+        @Override
+        public SliceIdentifier getIdentifierOf(JavaClass javaClass) {
+            String packageName = javaClass.getPackageName();
+            if (packageName.startsWith("io.github.ngirchev.opendaimon.ai.springai.advisor")) {
+                return SliceIdentifier.of("advisor");
+            }
+            if (packageName.startsWith("io.github.ngirchev.opendaimon.ai.springai.agent")) {
+                return SliceIdentifier.of("agent");
+            }
+            if (packageName.startsWith("io.github.ngirchev.opendaimon.ai.springai.embedding")) {
+                return SliceIdentifier.of("embedding");
+            }
+            if (packageName.startsWith("io.github.ngirchev.opendaimon.ai.springai.memory")) {
+                return SliceIdentifier.of("memory");
+            }
+            if (packageName.startsWith("io.github.ngirchev.opendaimon.ai.springai.rag")) {
+                return SliceIdentifier.of("rag");
+            }
+            if (packageName.startsWith("io.github.ngirchev.opendaimon.ai.springai.rest")) {
+                return SliceIdentifier.of("rest-client");
+            }
+            if (packageName.startsWith("io.github.ngirchev.opendaimon.ai.springai.retry")) {
+                return SliceIdentifier.of("retry");
+            }
+            if (packageName.startsWith("io.github.ngirchev.opendaimon.ai.springai.service")) {
+                return SliceIdentifier.of("service");
+            }
+            if (packageName.startsWith("io.github.ngirchev.opendaimon.ai.springai.tool")) {
+                return SliceIdentifier.of("tool");
+            }
+            return SliceIdentifier.ignore();
+        }
+
+        @Override
+        public String getDescription() {
+            return "spring-ai runtime slices";
+        }
+    };
+
+    @ArchTest
+    static final ArchRule spring_ai_uses_no_service_or_component_stereotypes =
+            noClasses()
+                    .should().beAnnotatedWith(Service.class)
+                    .orShould().beAnnotatedWith(Component.class)
+                    .because("spring-ai exports Spring beans through explicit auto-configuration.");
+
+    @ArchTest
+    static final ArchRule spring_ai_uses_no_repository_classes =
+            noClasses()
+                    .that().areNotInterfaces()
+                    .should().beAnnotatedWith(Repository.class)
+                    .because("@Repository is only allowed on Spring Data repository interfaces.");
+
+    @ArchTest
+    static final ArchRule bean_methods_are_declared_only_in_config_packages =
+            methods()
+                    .that().areAnnotatedWith(Bean.class)
+                    .should().beDeclaredInClassesThat().resideInAPackage("..springai.config..")
+                    .because("spring-ai beans must be exposed through explicit auto-configuration classes.");
+
+    @ArchTest
+    static final ArchRule configuration_classes_are_declared_only_in_config_packages =
+            classes()
+                    .that().areAnnotatedWith(AutoConfiguration.class)
+                    .or().areAnnotatedWith(Configuration.class)
+                    .should().resideInAPackage("..springai.config..")
+                    .because("Spring configuration belongs in config packages.");
+
+    @ArchTest
+    static final ArchRule configuration_properties_are_declared_only_in_config_packages =
+            classes()
+                    .that().areAnnotatedWith(ConfigurationProperties.class)
+                    .should().resideInAPackage("..springai.config..")
+                    .andShould().haveSimpleNameEndingWith("Properties")
+                    .andShould().beAnnotatedWith(Validated.class)
+                    .because("spring-ai configuration properties must stay validated in config packages.");
+
+    @ArchTest
+    static final ArchRule runtime_slices_have_no_cycles =
+            slices().assignedFrom(SPRING_AI_RUNTIME_SLICES)
+                    .should().beFreeOfCycles()
+                    .because("spring-ai runtime packages should stay independently understandable.");
+}
diff --git a/opendaimon-spring-ai/src/test/java/io/github/ngirchev/opendaimon/ai/springai/memory/SummarizingChatMemoryTest.java b/opendaimon-spring-ai/src/test/java/io/github/ngirchev/opendaimon/ai/springai/memory/SummarizingChatMemoryTest.java
index b58fda18..ce77423a 100644
--- a/opendaimon-spring-ai/src/test/java/io/github/ngirchev/opendaimon/ai/springai/memory/SummarizingChatMemoryTest.java
+++ b/opendaimon-spring-ai/src/test/java/io/github/ngirchev/opendaimon/ai/springai/memory/SummarizingChatMemoryTest.java
@@ -3,8 +3,8 @@
 import io.github.ngirchev.opendaimon.common.model.MessageRole;
 import io.github.ngirchev.opendaimon.common.model.OpenDaimonMessage;
 import io.github.ngirchev.opendaimon.common.model.ConversationThread;
-import io.github.ngirchev.opendaimon.common.repository.OpenDaimonMessageRepository;
-import io.github.ngirchev.opendaimon.common.repository.ConversationThreadRepository;
+import io.github.ngirchev.opendaimon.common.service.ConversationThreadService;
+import io.github.ngirchev.opendaimon.common.service.OpenDaimonMessageService;
 import io.github.ngirchev.opendaimon.common.service.SummarizationService;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -56,9 +56,9 @@ class SummarizingChatMemoryTest {
     private SummarizingChatMemory summarizingChatMemory;
 
     @Mock
-    private ConversationThreadRepository conversationThreadRepository;
+    private ConversationThreadService conversationThreadService;
     @Mock
-    private OpenDaimonMessageRepository messageRepository;
+    private OpenDaimonMessageService messageService;
     @Mock
     private SummarizationService summarizationService;
     @Mock
@@ -69,8 +69,8 @@ void setUp() {
         ChatMemoryRepository chatMemoryRepository = new InMemoryChatMemoryRepository();
         summarizingChatMemory = new SummarizingChatMemory(
                 chatMemoryRepository,
-                conversationThreadRepository,
-                messageRepository,
+                conversationThreadService,
+                messageService,
                 summarizationService,
                 eventPublisher,
                 MAX_MESSAGES,
@@ -82,12 +82,12 @@ void setUp() {
     void whenGetWithFewerThanMaxMessages_thenReturnsMessagesWithoutSummarization() {
         summarizingChatMemory.add(CONVERSATION_ID, new UserMessage("Hello"));
         summarizingChatMemory.add(CONVERSATION_ID, new AssistantMessage("Hi"));
-        when(conversationThreadRepository.findByThreadKey(CONVERSATION_ID)).thenReturn(Optional.empty());
+        when(conversationThreadService.findByThreadKey(CONVERSATION_ID)).thenReturn(Optional.empty());
 
         List<Message> result = summarizingChatMemory.get(CONVERSATION_ID);
 
         assertEquals(2, result.size());
-        verify(conversationThreadRepository, times(1)).findByThreadKey(CONVERSATION_ID);
+        verify(conversationThreadService, times(1)).findByThreadKey(CONVERSATION_ID);
         verify(summarizationService, never()).summarizeThread(any(), any());
     }
 
@@ -129,11 +129,11 @@ void whenGetWithMessageCountAtMax_thenSummarizationTriggered() {
         for (int i = 0; i < MAX_MESSAGES; i++) {
             summarizingChatMemory.add(CONVERSATION_ID, new UserMessage("u" + i));
         }
-        when(conversationThreadRepository.findByThreadKey(CONVERSATION_ID)).thenReturn(Optional.empty());
+        when(conversationThreadService.findByThreadKey(CONVERSATION_ID)).thenReturn(Optional.empty());
 
         summarizingChatMemory.get(CONVERSATION_ID);
 
-        verify(conversationThreadRepository).findByThreadKey(CONVERSATION_ID);
+        verify(conversationThreadService).findByThreadKey(CONVERSATION_ID);
     }
 
     @Test
@@ -142,11 +142,11 @@ void whenGetWithMessageCountBelowMax_thenSummarizationNotTriggered() {
         for (int i = 0; i < MAX_MESSAGES - 1; i++) {
             summarizingChatMemory.add(CONVERSATION_ID, new UserMessage("u" + i));
         }
-        when(conversationThreadRepository.findByThreadKey(CONVERSATION_ID)).thenReturn(Optional.empty());
+        when(conversationThreadService.findByThreadKey(CONVERSATION_ID)).thenReturn(Optional.empty());
 
         summarizingChatMemory.get(CONVERSATION_ID);
 
-        verify(conversationThreadRepository, times(1)).findByThreadKey(CONVERSATION_ID);
+        verify(conversationThreadService, times(1)).findByThreadKey(CONVERSATION_ID);
         verify(summarizationService, never()).summarizeThread(any(), any());
     }
 
@@ -156,13 +156,13 @@ void whenGetWithMessageCountAtMaxAndThreadNotFound_thenReturnsDelegateMessagesWi
             summarizingChatMemory.add(CONVERSATION_ID, new UserMessage("u" + i));
             summarizingChatMemory.add(CONVERSATION_ID, new AssistantMessage("a" + i));
         }
-        when(conversationThreadRepository.findByThreadKey(CONVERSATION_ID)).thenReturn(Optional.empty());
+        when(conversationThreadService.findByThreadKey(CONVERSATION_ID)).thenReturn(Optional.empty());
 
         List<Message> result = summarizingChatMemory.get(CONVERSATION_ID);
 
         // Delegate (MessageWindowChatMemory) keeps only last maxMessages messages
         assertEquals(MAX_MESSAGES, result.size());
-        verify(conversationThreadRepository).findByThreadKey(CONVERSATION_ID);
+        verify(conversationThreadService).findByThreadKey(CONVERSATION_ID);
         verify(summarizationService, never()).summarizeThread(any(), any());
     }
 
@@ -174,14 +174,14 @@ void whenGetWithMessageCountAtMaxAndThreadFoundButOnlyOneMessageInDb_thenSummari
         }
         ConversationThread thread = new ConversationThread();
         thread.setThreadKey(CONVERSATION_ID);
-        when(conversationThreadRepository.findByThreadKey(CONVERSATION_ID)).thenReturn(Optional.of(thread));
+        when(conversationThreadService.findByThreadKey(CONVERSATION_ID)).thenReturn(Optional.of(thread));
         // One message: size < 2, partial summarization is skipped
-        when(messageRepository.findByThreadAndSequenceNumberGreaterThanOrderBySequenceNumberAsc(eq(thread), any()))
+        when(messageService.findByThreadAndSequenceNumberGreaterThanOrderBySequenceNumberAsc(eq(thread), any()))
                 .thenReturn(new ArrayList<>(List.of(createMockMessage(MessageRole.USER))));
 
         List<Message> result = summarizingChatMemory.get(CONVERSATION_ID);
 
-        verify(conversationThreadRepository, atLeastOnce()).findByThreadKey(CONVERSATION_ID);
+        verify(conversationThreadService, atLeastOnce()).findByThreadKey(CONVERSATION_ID);
         verify(summarizationService, never()).summarizeThread(any(), any());
     }
 
@@ -199,7 +199,7 @@ void whenGetWithMessageCountAtMaxAndSummarizationSucceeds_thenChatMemoryContains
         threadWithSummary.setSummary("Previous talk summary");
         threadWithSummary.setMemoryBullets(List.of("Point one", "Point two"));
 
-        when(conversationThreadRepository.findByThreadKey(CONVERSATION_ID))
+        when(conversationThreadService.findByThreadKey(CONVERSATION_ID))
                 .thenReturn(Optional.of(thread))
                 .thenReturn(Optional.of(threadWithSummary));
         // 4 messages in DB: partial summarization splits into 2 to summarize + 2 to keep
@@ -208,7 +208,7 @@ void whenGetWithMessageCountAtMaxAndSummarizationSucceeds_thenChatMemoryContains
                 createMockMessage(MessageRole.ASSISTANT),
                 createMockMessage(MessageRole.USER),
                 createMockMessage(MessageRole.ASSISTANT)));
-        when(messageRepository.findByThreadAndSequenceNumberGreaterThanOrderBySequenceNumberAsc(eq(thread), any()))
+        when(messageService.findByThreadAndSequenceNumberGreaterThanOrderBySequenceNumberAsc(eq(thread), any()))
                 .thenReturn(dbMessages);
 
         List<Message> result = summarizingChatMemory.get(CONVERSATION_ID);
@@ -242,7 +242,7 @@ void whenGetWithMessageCountAtMaxAndSummarizationReturnsEmptySummary_thenNoSumma
         threadAfterSummary.setThreadKey(CONVERSATION_ID);
         threadAfterSummary.setSummary(null);
 
-        when(conversationThreadRepository.findByThreadKey(CONVERSATION_ID))
+        when(conversationThreadService.findByThreadKey(CONVERSATION_ID))
                 .thenReturn(Optional.of(thread))
                 .thenReturn(Optional.of(threadAfterSummary));
         ArrayList<OpenDaimonMessage> dbMessages = new ArrayList<>(List.of(
@@ -250,7 +250,7 @@ void whenGetWithMessageCountAtMaxAndSummarizationReturnsEmptySummary_thenNoSumma
                 createMockMessage(MessageRole.ASSISTANT),
                 createMockMessage(MessageRole.USER),
                 createMockMessage(MessageRole.ASSISTANT)));
-        when(messageRepository.findByThreadAndSequenceNumberGreaterThanOrderBySequenceNumberAsc(eq(thread), any()))
+        when(messageService.findByThreadAndSequenceNumberGreaterThanOrderBySequenceNumberAsc(eq(thread), any()))
                 .thenReturn(dbMessages);
 
         List<Message> result = summarizingChatMemory.get(CONVERSATION_ID);
@@ -272,8 +272,8 @@ void whenSummarizationServiceThrows_thenSummarizationFailedExceptionPropagates()
         }
         ConversationThread thread = new ConversationThread();
         thread.setThreadKey(CONVERSATION_ID);
-        when(conversationThreadRepository.findByThreadKey(CONVERSATION_ID)).thenReturn(Optional.of(thread));
-        when(messageRepository.findByThreadAndSequenceNumberGreaterThanOrderBySequenceNumberAsc(eq(thread), any()))
+        when(conversationThreadService.findByThreadKey(CONVERSATION_ID)).thenReturn(Optional.of(thread));
+        when(messageService.findByThreadAndSequenceNumberGreaterThanOrderBySequenceNumberAsc(eq(thread), any()))
                 .thenReturn(new ArrayList<>(List.of(
                         createMockMessage(MessageRole.USER),
                         createMockMessage(MessageRole.ASSISTANT),
@@ -297,12 +297,12 @@ void whenTokenLimitReachedButMessagesBeforeLimit_thenSummarizationTriggeredByTok
         thread.setThreadKey(CONVERSATION_ID);
         thread.setTotalTokens((long) MAX_WINDOW_TOKENS); // At the limit
 
-        when(conversationThreadRepository.findByThreadKey(CONVERSATION_ID)).thenReturn(Optional.of(thread));
+        when(conversationThreadService.findByThreadKey(CONVERSATION_ID)).thenReturn(Optional.of(thread));
 
         summarizingChatMemory.get(CONVERSATION_ID);
 
         // Token check in get(), then load thread again in performSummarizationAndUpdateChatMemory
-        verify(conversationThreadRepository, times(2)).findByThreadKey(CONVERSATION_ID);
+        verify(conversationThreadService, times(2)).findByThreadKey(CONVERSATION_ID);
     }
 
     @Test
@@ -316,12 +316,12 @@ void whenTokensBeforeLimitAndMessagesBeforeLimit_thenSummarizationNotTriggered()
         thread.setThreadKey(CONVERSATION_ID);
         thread.setTotalTokens(5000L); // Well below MAX_WINDOW_TOKENS=16000
 
-        when(conversationThreadRepository.findByThreadKey(CONVERSATION_ID)).thenReturn(Optional.of(thread));
+        when(conversationThreadService.findByThreadKey(CONVERSATION_ID)).thenReturn(Optional.of(thread));
 
         summarizingChatMemory.get(CONVERSATION_ID);
 
         // Thread is loaded once to evaluate totalTokens vs maxWindowTokens
-        verify(conversationThreadRepository, times(1)).findByThreadKey(CONVERSATION_ID);
+        verify(conversationThreadService, times(1)).findByThreadKey(CONVERSATION_ID);
         verify(summarizationService, never()).summarizeThread(any(), any());
     }
 
@@ -338,10 +338,10 @@ void shouldDropTrailingInFlightUserMessageWhenRestoringFromPrimaryStore() {
         // Delegate is empty (fresh app start / eviction) — get() triggers primary-store restore.
         ConversationThread thread = new ConversationThread();
         thread.setThreadKey(CONVERSATION_ID);
-        when(conversationThreadRepository.findByThreadKey(CONVERSATION_ID))
+        when(conversationThreadService.findByThreadKey(CONVERSATION_ID))
                 .thenReturn(Optional.of(thread));
         // Primary store: 3 ASSISTANT turns interleaved with USER, tail is an in-flight USER row.
-        when(messageRepository.findByThreadAndSequenceNumberGreaterThanOrderBySequenceNumberAsc(eq(thread), any()))
+        when(messageService.findByThreadAndSequenceNumberGreaterThanOrderBySequenceNumberAsc(eq(thread), any()))
                 .thenReturn(new ArrayList<>(List.of(
                         createMockMessage(MessageRole.USER, "u0"),
                         createMockMessage(MessageRole.ASSISTANT, "a0"),
@@ -371,14 +371,14 @@ void shouldDropTrailingInFlightUserMessageWhenRestoringFromPrimaryStore() {
     void shouldDropTrailingInFlightUserMessageWithAttachmentsEnrichment() {
         ConversationThread thread = new ConversationThread();
         thread.setThreadKey(CONVERSATION_ID);
-        when(conversationThreadRepository.findByThreadKey(CONVERSATION_ID))
+        when(conversationThreadService.findByThreadKey(CONVERSATION_ID))
                 .thenReturn(Optional.of(thread));
 
         OpenDaimonMessage trailingUserWithAttachments = createMockMessage(MessageRole.USER, "describe this");
         trailingUserWithAttachments.setAttachments(List.of(
                 java.util.Map.of("type", "image", "name", "photo.jpg")));
 
-        when(messageRepository.findByThreadAndSequenceNumberGreaterThanOrderBySequenceNumberAsc(eq(thread), any()))
+        when(messageService.findByThreadAndSequenceNumberGreaterThanOrderBySequenceNumberAsc(eq(thread), any()))
                 .thenReturn(new ArrayList<>(List.of(
                         createMockMessage(MessageRole.USER, "earlier prompt"),
                         createMockMessage(MessageRole.ASSISTANT, "earlier reply"),
diff --git a/opendaimon-spring-ai/src/test/java/io/github/ngirchev/opendaimon/ai/springai/retry/ModelSelectionPriorityTest.java b/opendaimon-spring-ai/src/test/java/io/github/ngirchev/opendaimon/ai/springai/retry/ModelSelectionPriorityTest.java
index 7fd2c236..0ad62b1a 100644
--- a/opendaimon-spring-ai/src/test/java/io/github/ngirchev/opendaimon/ai/springai/retry/ModelSelectionPriorityTest.java
+++ b/opendaimon-spring-ai/src/test/java/io/github/ngirchev/opendaimon/ai/springai/retry/ModelSelectionPriorityTest.java
@@ -1,5 +1,6 @@
 package io.github.ngirchev.opendaimon.ai.springai.retry;
 
+import io.github.ngirchev.opendaimon.ai.springai.config.OpenRouterModelsProperties;
 import io.github.ngirchev.opendaimon.ai.springai.config.SpringAIModelConfig;
 import io.github.ngirchev.opendaimon.common.ai.ModelCapabilities;
 import org.junit.jupiter.api.BeforeEach;
diff --git a/opendaimon-spring-ai/src/test/java/io/github/ngirchev/opendaimon/ai/springai/retry/OpenRouterEmbeddingModelsFetchTest.java b/opendaimon-spring-ai/src/test/java/io/github/ngirchev/opendaimon/ai/springai/retry/OpenRouterEmbeddingModelsFetchTest.java
index 0aa0c561..554ab5ab 100644
--- a/opendaimon-spring-ai/src/test/java/io/github/ngirchev/opendaimon/ai/springai/retry/OpenRouterEmbeddingModelsFetchTest.java
+++ b/opendaimon-spring-ai/src/test/java/io/github/ngirchev/opendaimon/ai/springai/retry/OpenRouterEmbeddingModelsFetchTest.java
@@ -1,6 +1,7 @@
 package io.github.ngirchev.opendaimon.ai.springai.retry;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
+import io.github.ngirchev.opendaimon.ai.springai.config.OpenRouterModelsProperties;
 import io.github.ngirchev.opendaimon.ai.springai.config.SpringAIModelConfig;
 import io.github.ngirchev.opendaimon.common.ai.ModelCapabilities;
 import org.junit.jupiter.api.BeforeEach;
diff --git a/opendaimon-spring-ai/src/test/java/io/github/ngirchev/opendaimon/ai/springai/retry/OpenRouterFreeModelResolverTest.java b/opendaimon-spring-ai/src/test/java/io/github/ngirchev/opendaimon/ai/springai/retry/OpenRouterFreeModelResolverTest.java
index 50f4daab..3c9cb321 100644
--- a/opendaimon-spring-ai/src/test/java/io/github/ngirchev/opendaimon/ai/springai/retry/OpenRouterFreeModelResolverTest.java
+++ b/opendaimon-spring-ai/src/test/java/io/github/ngirchev/opendaimon/ai/springai/retry/OpenRouterFreeModelResolverTest.java
@@ -1,6 +1,7 @@
 package io.github.ngirchev.opendaimon.ai.springai.retry;
 
 import io.github.ngirchev.opendaimon.common.ai.ModelCapabilities;
+import io.github.ngirchev.opendaimon.ai.springai.config.OpenRouterModelsProperties;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
diff --git a/opendaimon-spring-ai/src/test/java/io/github/ngirchev/opendaimon/ai/springai/retry/SpringAIModelRegistryTest.java b/opendaimon-spring-ai/src/test/java/io/github/ngirchev/opendaimon/ai/springai/retry/SpringAIModelRegistryTest.java
index 846eb30a..dc4e5ed6 100644
--- a/opendaimon-spring-ai/src/test/java/io/github/ngirchev/opendaimon/ai/springai/retry/SpringAIModelRegistryTest.java
+++ b/opendaimon-spring-ai/src/test/java/io/github/ngirchev/opendaimon/ai/springai/retry/SpringAIModelRegistryTest.java
@@ -1,6 +1,7 @@
 package io.github.ngirchev.opendaimon.ai.springai.retry;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
+import io.github.ngirchev.opendaimon.ai.springai.config.OpenRouterModelsProperties;
 import io.github.ngirchev.opendaimon.ai.springai.config.SpringAIModelConfig;
 import io.github.ngirchev.opendaimon.bulkhead.model.UserPriority;
 import org.junit.jupiter.api.BeforeEach;
diff --git a/opendaimon-spring-boot-starter/pom.xml b/opendaimon-spring-boot-starter/pom.xml
new file mode 100644
index 00000000..6d1a1fd9
--- /dev/null
+++ b/opendaimon-spring-boot-starter/pom.xml
@@ -0,0 +1,84 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <!-- @cursor: AI, follow this dependency structure in this pom.xml:
+     1. Project-specific modules (groupId starts with io.github.ngirchev)
+     2. Spring dependencies (groupId starts with org.springframework)
+     3. Database dependencies (e.g., jdbc, jpa, postgres, h2)
+     4. Other utilities and libraries (e.g., logging, json, etc.)
+     5. Test-related dependencies (with <scope>test</scope>)
+     Also: All versions must be extracted to the <properties> section.
+    -->
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>io.github.ngirchev</groupId>
+        <artifactId>opendaimon</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>opendaimon-spring-boot-starter</artifactId>
+    <name>OpenDaimon Spring Boot Starter</name>
+
+    <properties>
+        <java.version>21</java.version>
+        <maven.compiler.source>21</maven.compiler.source>
+        <maven.compiler.target>21</maven.compiler.target>
+
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
+    </properties>
+
+    <dependencies>
+        <!-- Project Dependencies -->
+        <dependency>
+            <groupId>io.github.ngirchev</groupId>
+            <artifactId>opendaimon-common</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>io.github.ngirchev</groupId>
+            <artifactId>opendaimon-spring-ai</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+
+        <!-- Spring -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-core</artifactId>
+        </dependency>
+
+        <!-- Test -->
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-dependency-plugin</artifactId>
+                <configuration>
+                    <ignoredUnusedDeclaredDependencies>
+                        <!-- Starter module exposes these dependencies to downstream applications;
+                             source analysis cannot see resource-only aggregation. -->
+                        <ignored>io.github.ngirchev:opendaimon-common</ignored>
+                        <ignored>io.github.ngirchev:opendaimon-spring-ai</ignored>
+                    </ignoredUnusedDeclaredDependencies>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>
diff --git a/opendaimon-spring-boot-starter/src/main/java/io/github/ngirchev/opendaimon/starter/OpenDaimonDefaultsEnvironmentPostProcessor.java b/opendaimon-spring-boot-starter/src/main/java/io/github/ngirchev/opendaimon/starter/OpenDaimonDefaultsEnvironmentPostProcessor.java
new file mode 100644
index 00000000..ffd58f1f
--- /dev/null
+++ b/opendaimon-spring-boot-starter/src/main/java/io/github/ngirchev/opendaimon/starter/OpenDaimonDefaultsEnvironmentPostProcessor.java
@@ -0,0 +1,40 @@
+package io.github.ngirchev.opendaimon.starter;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.env.EnvironmentPostProcessor;
+import org.springframework.boot.env.YamlPropertySourceLoader;
+import org.springframework.core.Ordered;
+import org.springframework.core.env.ConfigurableEnvironment;
+import org.springframework.core.io.ClassPathResource;
+
+public final class OpenDaimonDefaultsEnvironmentPostProcessor implements EnvironmentPostProcessor, Ordered {
+
+    static final String DEFAULTS_RESOURCE = "META-INF/opendaimon/opendaimon-defaults.yml";
+    private static final String DEFAULTS_PROPERTY_SOURCE_NAME = "opendaimon-defaults";
+
+    @Override
+    public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
+        if (environment.getPropertySources().contains(DEFAULTS_PROPERTY_SOURCE_NAME)) {
+            return;
+        }
+
+        try {
+            var resource = new ClassPathResource(DEFAULTS_RESOURCE);
+            var loader = new YamlPropertySourceLoader();
+            var propertySources = loader.load(DEFAULTS_PROPERTY_SOURCE_NAME, resource);
+            for (var propertySource : propertySources.reversed()) {
+                environment.getPropertySources().addLast(propertySource);
+            }
+        } catch (IOException e) {
+            throw new UncheckedIOException("Failed to load OpenDaimon starter defaults", e);
+        }
+    }
+
+    @Override
+    public int getOrder() {
+        return Ordered.LOWEST_PRECEDENCE;
+    }
+}
diff --git a/opendaimon-spring-boot-starter/src/main/resources/META-INF/opendaimon/opendaimon-defaults.yml b/opendaimon-spring-boot-starter/src/main/resources/META-INF/opendaimon/opendaimon-defaults.yml
new file mode 100644
index 00000000..9719a07a
--- /dev/null
+++ b/opendaimon-spring-boot-starter/src/main/resources/META-INF/opendaimon/opendaimon-defaults.yml
@@ -0,0 +1,156 @@
+spring:
+  ai:
+    ollama:
+      base-url: ${OLLAMA_BASE_URL:http://localhost:11434}
+      request-timeout: 600s
+    openai:
+      base-url: https://openrouter.ai/api
+    chat:
+      memory:
+        repository:
+          jdbc:
+            initialize-schema: never
+
+open-daimon:
+  common:
+    storage:
+      enabled: false
+      minio:
+        endpoint: ${MINIO_ENDPOINT:http://localhost:9000}
+        access-key: ${MINIO_USER:minioadmin}
+        secret-key: ${MINIO_PASSWORD:minioadmin}
+        bucket: opendaimon-files
+        ttl-hours: 24
+    bulkhead:
+      enabled: false
+      instances:
+        ADMIN:
+          maxConcurrentCalls: 10
+          maxWaitDuration: 1s
+        VIP:
+          maxConcurrentCalls: 5
+          maxWaitDuration: 1s
+        REGULAR:
+          maxConcurrentCalls: 1
+          maxWaitDuration: 500ms
+    assistant-role: role.content.default
+    max-total-prompt-tokens: 32000
+    max-user-message-tokens: 4000
+    max-output-tokens: 4000
+    max-reasoning-tokens: 1500
+    chat-routing:
+      ADMIN:
+        max-price: 5.0
+        required-capabilities:
+          - AUTO
+        optional-capabilities: []
+      VIP:
+        max-price: 0.5
+        required-capabilities:
+          - CHAT
+        optional-capabilities:
+          - TOOL_CALLING
+          - WEB
+      REGULAR:
+        max-price: ${OPENDAIMON_REGULAR_MAX_PRICE:5.0}
+        required-capabilities:
+          - CHAT
+        optional-capabilities: []
+    summarization:
+      message-window-size: 50
+      max-window-tokens: 16000
+      max-output-tokens: 6000
+      prompt: |
+        You are summarizing a conversation for an AI assistant's long-term memory.
+        If a "Previous conversation summary" section is present, incorporate it into your new summary - produce a SINGLE UNIFIED summary, not a continuation.
+
+        Rules:
+        1. Summarize only what was ACTUALLY said - do not infer, interpret, or invent meaning. If messages are trivial (e.g. single words, numbers, test messages), state that plainly.
+        2. Summary: 2-4 paragraphs, max 500 words. Focus on user's goals, decisions made, problems solved, preferences expressed.
+        3. Memory bullets: up to 10 key facts the assistant must remember going forward. Omit bullets if there is nothing meaningful to remember.
+        4. If previous bullets exist, keep relevant ones, drop obsolete, deduplicate.
+        5. Respond in the SAME LANGUAGE as the conversation.
+        6. Reply in strict JSON only (no markdown, no backticks, no preamble):
+        {"summary": "...", "memory_bullets": ["fact 1", "fact 2", ...]}
+
+        Conversation:
+  ai:
+    spring-ai:
+      enabled: true
+      openrouter-app:
+        site-url: ${OPENROUTER_APP_SITE_URL:}
+        title: ${OPENROUTER_APP_TITLE:}
+      openrouter-auto-rotation:
+        models:
+          enabled: false
+          api:
+            key: ${OPENROUTER_KEY:}
+            url: https://openrouter.ai/api
+          refresh-initial-delay: 10s
+          refresh-interval: 24h
+          whitelist: []
+          blacklist:
+            exclude-model-ids: []
+            exclude-contains: []
+          ranking:
+            enabled: true
+            retry-max-attempts: 3
+            latency-ewma-alpha: 0.2
+            cooldown429: 10m
+            cooldown5xx: 5m
+            cooldown404: 6h
+      serper:
+        api:
+          url: https://google.serper.dev/search
+          key: ${SERPER_KEY:}
+      mock: false
+      timeouts:
+        response-timeout-seconds: 600
+      url-check:
+        enabled: true
+        timeout-ms: 3000
+        max-urls-per-answer: 10
+        cache-ttl-minutes: 10
+      ssl:
+        merge-system-keychain: true
+      models:
+        list:
+          - name: ${OPENDAIMON_DEFAULT_MODEL:${OPENROUTER_CONTRACT_MODEL:openrouter/auto}}
+            provider-type: ${OPENDAIMON_DEFAULT_PROVIDER:OPENAI}
+            priority: 1
+            capabilities:
+              - AUTO
+              - CHAT
+              - TOOL_CALLING
+              - WEB
+              - SUMMARIZATION
+              - VISION
+            allowed-roles:
+              - ADMIN
+              - VIP
+              - REGULAR
+      rag:
+        enabled: false
+        chunk-size: 800
+        chunk-overlap: 100
+        top-k: 5
+        similarity-threshold: 0.7
+        prompts:
+          document-extract-error-pdf: "Could not extract text from file \"%s\". The file may be a scanned/image-only PDF or corrupted."
+          document-extract-error-document: "Could not extract text from file \"%s\" (type: %s). The file may be unsupported or corrupted."
+          augmented-prompt-template: |
+            The user attached one or more documents. The following context was extracted from them.
+
+            Context:
+            %s
+
+            User question:
+            %s
+          vision-extraction-prompt: "Extract ALL text content from this image exactly as written. Include all headings, paragraphs, tables, lists, captions, and any visible text. Preserve the original structure and formatting as much as possible. Output only the extracted text, no commentary."
+  agent:
+    enabled: true
+    max-iterations: 10
+    stream-timeout-seconds: 600
+    tools:
+      http-api:
+        enabled: true
diff --git a/opendaimon-spring-boot-starter/src/main/resources/META-INF/spring.factories b/opendaimon-spring-boot-starter/src/main/resources/META-INF/spring.factories
new file mode 100644
index 00000000..584d1f78
--- /dev/null
+++ b/opendaimon-spring-boot-starter/src/main/resources/META-INF/spring.factories
@@ -0,0 +1,2 @@
+org.springframework.boot.env.EnvironmentPostProcessor=\
+io.github.ngirchev.opendaimon.starter.OpenDaimonDefaultsEnvironmentPostProcessor
diff --git a/opendaimon-spring-boot-starter/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports b/opendaimon-spring-boot-starter/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
new file mode 100644
index 00000000..46d9bd04
--- /dev/null
+++ b/opendaimon-spring-boot-starter/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
@@ -0,0 +1,6 @@
+io.github.ngirchev.opendaimon.common.config.CoreAutoConfig
+io.github.ngirchev.opendaimon.bulkhead.config.BulkHeadAutoConfig
+io.github.ngirchev.opendaimon.common.storage.config.StorageAutoConfig
+io.github.ngirchev.opendaimon.ai.springai.config.SpringAIAutoConfig
+io.github.ngirchev.opendaimon.ai.springai.config.RAGAutoConfig
+io.github.ngirchev.opendaimon.ai.springai.config.AgentAutoConfig
diff --git a/opendaimon-spring-boot-starter/src/test/java/io/github/ngirchev/opendaimon/starter/OpenDaimonDefaultsEnvironmentPostProcessorTest.java b/opendaimon-spring-boot-starter/src/test/java/io/github/ngirchev/opendaimon/starter/OpenDaimonDefaultsEnvironmentPostProcessorTest.java
new file mode 100644
index 00000000..4a95f73e
--- /dev/null
+++ b/opendaimon-spring-boot-starter/src/test/java/io/github/ngirchev/opendaimon/starter/OpenDaimonDefaultsEnvironmentPostProcessorTest.java
@@ -0,0 +1,74 @@
+package io.github.ngirchev.opendaimon.starter;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.nio.charset.StandardCharsets;
+import java.util.Map;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.SpringApplication;
+import org.springframework.core.env.MapPropertySource;
+import org.springframework.core.env.StandardEnvironment;
+
+class OpenDaimonDefaultsEnvironmentPostProcessorTest {
+
+    private static final String SPRING_FACTORIES_RESOURCE = "META-INF/spring.factories";
+
+    @Test
+    void shouldRegisterEnvironmentPostProcessorInSpringFactories() {
+        assertThat(loadResource(SPRING_FACTORIES_RESOURCE))
+                .contains("org.springframework.boot.env.EnvironmentPostProcessor")
+                .contains(OpenDaimonDefaultsEnvironmentPostProcessor.class.getName());
+    }
+
+    @Test
+    void shouldLoadStarterDefaultsAtLowestPrecedence() {
+        var environment = new StandardEnvironment();
+        environment.getPropertySources().addFirst(new MapPropertySource(
+                "consumer-application",
+                Map.of(
+                        "open-daimon.common.max-output-tokens", 1234,
+                        "open-daimon.agent.max-iterations", 2)));
+
+        new OpenDaimonDefaultsEnvironmentPostProcessor()
+                .postProcessEnvironment(environment, new SpringApplication(Object.class));
+
+        assertThat(environment.getProperty("open-daimon.ai.spring-ai.enabled", Boolean.class))
+                .isTrue();
+        assertThat(environment.getProperty("open-daimon.common.storage.enabled", Boolean.class))
+                .isFalse();
+        assertThat(environment.getProperty("open-daimon.common.bulkhead.enabled", Boolean.class))
+                .isFalse();
+        assertThat(environment.getProperty("open-daimon.ai.spring-ai.rag.enabled", Boolean.class))
+                .isFalse();
+        assertThat(environment.getProperty("open-daimon.agent.enabled", Boolean.class))
+                .isTrue();
+        assertThat(environment.getProperty("spring.ai.openai.base-url"))
+                .isEqualTo("https://openrouter.ai/api");
+        assertThat(environment.getProperty("open-daimon.ai.spring-ai.url-check.enabled", Boolean.class))
+                .isTrue();
+        assertThat(environment.getProperty("open-daimon.ai.spring-ai.serper.api.key"))
+                .isEmpty();
+        assertThat(environment.getProperty("open-daimon.ai.spring-ai.models.list[0].capabilities[0]"))
+                .isEqualTo("AUTO");
+        assertThat(environment.getProperty("open-daimon.common.max-output-tokens", Integer.class))
+                .isEqualTo(1234);
+        assertThat(environment.getProperty("open-daimon.agent.max-iterations", Integer.class))
+                .isEqualTo(2);
+        assertThat(environment.containsProperty("open-daimon.rest.enabled"))
+                .isFalse();
+    }
+
+    private String loadResource(String resourceName) {
+        try (var input = Thread.currentThread()
+                .getContextClassLoader()
+                .getResourceAsStream(resourceName)) {
+            assertThat(input).as(resourceName).isNotNull();
+            return new String(input.readAllBytes(), StandardCharsets.UTF_8);
+        } catch (IOException e) {
+            throw new UncheckedIOException(e);
+        }
+    }
+}
diff --git a/opendaimon-spring-boot-starter/src/test/java/io/github/ngirchev/opendaimon/starter/OpenDaimonStarterAutoConfigurationImportsTest.java b/opendaimon-spring-boot-starter/src/test/java/io/github/ngirchev/opendaimon/starter/OpenDaimonStarterAutoConfigurationImportsTest.java
new file mode 100644
index 00000000..e64170bd
--- /dev/null
+++ b/opendaimon-spring-boot-starter/src/test/java/io/github/ngirchev/opendaimon/starter/OpenDaimonStarterAutoConfigurationImportsTest.java
@@ -0,0 +1,46 @@
+package io.github.ngirchev.opendaimon.starter;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+
+class OpenDaimonStarterAutoConfigurationImportsTest {
+
+    private static final String IMPORTS_RESOURCE =
+            "META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports";
+
+    @Test
+    void shouldExposeCommonAndSpringAiAutoConfigurations() {
+        assertThat(loadAutoConfigurationImports())
+                .containsExactly(
+                        "io.github.ngirchev.opendaimon.common.config.CoreAutoConfig",
+                        "io.github.ngirchev.opendaimon.bulkhead.config.BulkHeadAutoConfig",
+                        "io.github.ngirchev.opendaimon.common.storage.config.StorageAutoConfig",
+                        "io.github.ngirchev.opendaimon.ai.springai.config.SpringAIAutoConfig",
+                        "io.github.ngirchev.opendaimon.ai.springai.config.RAGAutoConfig",
+                        "io.github.ngirchev.opendaimon.ai.springai.config.AgentAutoConfig");
+    }
+
+    private List<String> loadAutoConfigurationImports() {
+        try (var input = Thread.currentThread()
+                .getContextClassLoader()
+                .getResourceAsStream(IMPORTS_RESOURCE)) {
+            assertThat(input).as("starter auto-configuration imports resource").isNotNull();
+
+            var content = new String(input.readAllBytes(), StandardCharsets.UTF_8);
+
+            return content.lines()
+                    .map(String::trim)
+                    .filter(line -> !line.isEmpty())
+                    .filter(line -> !line.startsWith("#"))
+                    .toList();
+        } catch (IOException e) {
+            throw new UncheckedIOException(e);
+        }
+    }
+}
diff --git a/opendaimon-starter-consumer-example/README.md b/opendaimon-starter-consumer-example/README.md
new file mode 100644
index 00000000..c8910024
--- /dev/null
+++ b/opendaimon-starter-consumer-example/README.md
@@ -0,0 +1,70 @@
+# OpenDaimon Starter Consumer Example
+
+This is a standalone Maven project that simulates an external Spring Boot application consuming OpenDaimon through the starter.
+
+It is intentionally not listed in the root `pom.xml` modules and is not part of the published OpenDaimon reactor.
+
+The example declares two OpenDaimon dependencies:
+
+```xml
+<dependency>
+    <groupId>io.github.ngirchev</groupId>
+    <artifactId>opendaimon-spring-boot-starter</artifactId>
+    <version>${open-daimon.version}</version>
+</dependency>
+<dependency>
+    <groupId>io.github.ngirchev</groupId>
+    <artifactId>opendaimon-rest</artifactId>
+    <version>${open-daimon.version}</version>
+</dependency>
+```
+
+The starter brings the common and Spring AI modules, auto-configuration imports, and low-priority OpenDaimon defaults from `META-INF/opendaimon/opendaimon-defaults.yml`. `opendaimon-rest` is declared separately because REST API delivery is optional and is not part of the minimal starter dependency set.
+
+Starter defaults, overrideable from the consumer application's own configuration:
+
+- `open-daimon.ai.spring-ai.enabled=true`
+- `open-daimon.agent.enabled=true`
+- safe defaults for common token limits, summarization, storage, bulkhead, and priority routing
+- Spring AI sample: OpenRouter-compatible OpenAI provider with `openrouter/auto`
+- Spring AI provider endpoint: `spring.ai.openai.base-url=https://openrouter.ai/api`
+- Spring AI defaults for OpenRouter auto-rotation, Serper, URL checking, SSL, RAG, and agent settings
+- infrastructure-backed features are disabled by default where enabling them would require extra services or optional dependencies: storage, bulkhead, RAG, and OpenRouter model rotation
+- Optional overrides: `OPENDAIMON_DEFAULT_MODEL`, `OPENDAIMON_DEFAULT_PROVIDER`, and `OPENROUTER_CONTRACT_MODEL`
+
+Included OpenDaimon configuration in `src/main/resources/application.yml`:
+
+- REST opt-in: `open-daimon.rest.enabled=true`
+- REST access sample: `admin@example.com` and `user@example.com`
+
+The consumer application provides regular Spring Boot infrastructure dependencies (`spring-boot-starter-web`, `spring-boot-starter-data-jpa`, `spring-boot-starter-validation`, and PostgreSQL JDBC). It also calls `DotEnvLoader.loadDotEnv()` on startup, so secrets such as `OPENROUTER_KEY`, `SPRING_DATASOURCE_URL`, `SPRING_DATASOURCE_USERNAME`, or `SPRING_DATASOURCE_PASSWORD` can be kept in a local `.env` file. At runtime it expects PostgreSQL and OpenRouter unless you replace those settings.
+
+For local PostgreSQL the example accepts standard Spring Boot datasource variables:
+
+```properties
+SPRING_DATASOURCE_URL=jdbc:postgresql://localhost:5432/opendaimon
+SPRING_DATASOURCE_USERNAME=postgres
+SPRING_DATASOURCE_PASSWORD=postgres
+```
+
+If PostgreSQL reports `password authentication failed`, make these values match the credentials used when the local `open-daimon-postgres` container or database was first created.
+
+Run it against locally installed snapshots:
+
+```bash
+./mvnw -pl opendaimon-spring-boot-starter,opendaimon-rest -am install -DskipTests -DskipITs -DskipIT
+mvn -f opendaimon-starter-consumer-example/pom.xml test
+```
+
+The smoke test verifies that Spring Boot can discover OpenDaimon auto-configuration candidates from the consumer classpath without manually importing OpenDaimon configuration, that starter defaults for Spring AI are present on the classpath, and that REST is enabled by the consumer application because `opendaimon-rest` is an explicit dependency.
+
+The example also contains a manual-only contract test that starts a PostgreSQL Testcontainer, boots the REST API, sends a chat-style request to `/api/v1/session`, and expects the answer to come from real OpenRouter:
+
+```bash
+mvn -f opendaimon-starter-consumer-example/pom.xml verify \
+  -DskipITs=false \
+  -Dit.test=OpenRouterRestContractIT \
+  -Dmanual.openrouter.rest-contract=true
+```
+
+The contract test loads `.env` from the repository root and from `opendaimon-starter-consumer-example/.env`. It requires Docker, outbound network access, and `OPENROUTER_KEY`; `OPENROUTER_CONTRACT_MODEL` is optional and defaults to `openrouter/auto`.
diff --git a/opendaimon-starter-consumer-example/pom.xml b/opendaimon-starter-consumer-example/pom.xml
new file mode 100644
index 00000000..b417c295
--- /dev/null
+++ b/opendaimon-starter-consumer-example/pom.xml
@@ -0,0 +1,144 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>io.github.ngirchev.opendaimon.examples</groupId>
+    <artifactId>opendaimon-starter-consumer-example</artifactId>
+    <version>1.0.0-SNAPSHOT</version>
+
+    <name>OpenDaimon Starter Consumer Example</name>
+    <description>Standalone consumer smoke test for the OpenDaimon Spring Boot starter.</description>
+
+    <properties>
+        <java.version>21</java.version>
+        <maven.compiler.source>21</maven.compiler.source>
+        <maven.compiler.target>21</maven.compiler.target>
+
+        <open-daimon.version>1.0.0-SNAPSHOT</open-daimon.version>
+        <spring-boot.version>3.5.13</spring-boot.version>
+        <testcontainers.version>1.21.4</testcontainers.version>
+        <dotenv.version>1.0.5</dotenv.version>
+
+        <maven-compiler-plugin.version>3.11.0</maven-compiler-plugin.version>
+        <maven-surefire-plugin.version>3.2.5</maven-surefire-plugin.version>
+        <maven-failsafe-plugin.version>3.2.5</maven-failsafe-plugin.version>
+        <skipITs>true</skipITs>
+
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
+    </properties>
+
+    <dependencyManagement>
+        <dependencies>
+            <dependency>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-dependencies</artifactId>
+                <version>${spring-boot.version}</version>
+                <type>pom</type>
+                <scope>import</scope>
+            </dependency>
+            <dependency>
+                <groupId>org.testcontainers</groupId>
+                <artifactId>testcontainers-bom</artifactId>
+                <version>${testcontainers.version}</version>
+                <type>pom</type>
+                <scope>import</scope>
+            </dependency>
+        </dependencies>
+    </dependencyManagement>
+
+    <dependencies>
+        <dependency>
+            <groupId>io.github.ngirchev</groupId>
+            <artifactId>opendaimon-spring-boot-starter</artifactId>
+            <version>${open-daimon.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>io.github.ngirchev</groupId>
+            <artifactId>opendaimon-rest</artifactId>
+            <version>${open-daimon.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-jpa</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-validation</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.postgresql</groupId>
+            <artifactId>postgresql</artifactId>
+            <scope>runtime</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>io.github.ngirchev</groupId>
+            <artifactId>dotenv</artifactId>
+            <version>${dotenv.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.testcontainers</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.testcontainers</groupId>
+            <artifactId>postgresql</artifactId>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>${maven-compiler-plugin.version}</version>
+                <configuration>
+                    <source>${java.version}</source>
+                    <target>${java.version}</target>
+                    <parameters>true</parameters>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>${maven-surefire-plugin.version}</version>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-failsafe-plugin</artifactId>
+                <version>${maven-failsafe-plugin.version}</version>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>integration-test</goal>
+                            <goal>verify</goal>
+                        </goals>
+                    </execution>
+                </executions>
+                <configuration>
+                    <skipITs>${skipITs}</skipITs>
+                    <includes>
+                        <include>**/*IT.java</include>
+                    </includes>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>
diff --git a/opendaimon-starter-consumer-example/src/main/java/io/github/ngirchev/opendaimon/example/StarterConsumerApplication.java b/opendaimon-starter-consumer-example/src/main/java/io/github/ngirchev/opendaimon/example/StarterConsumerApplication.java
new file mode 100644
index 00000000..01172888
--- /dev/null
+++ b/opendaimon-starter-consumer-example/src/main/java/io/github/ngirchev/opendaimon/example/StarterConsumerApplication.java
@@ -0,0 +1,14 @@
+package io.github.ngirchev.opendaimon.example;
+
+import io.github.ngirchev.dotenv.DotEnvLoader;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class StarterConsumerApplication {
+
+    public static void main(String[] args) {
+        DotEnvLoader.loadDotEnv();
+        SpringApplication.run(StarterConsumerApplication.class, args);
+    }
+}
diff --git a/opendaimon-starter-consumer-example/src/main/resources/application.yml b/opendaimon-starter-consumer-example/src/main/resources/application.yml
new file mode 100644
index 00000000..28220b1b
--- /dev/null
+++ b/opendaimon-starter-consumer-example/src/main/resources/application.yml
@@ -0,0 +1,25 @@
+spring:
+  application:
+    name: opendaimon-starter-consumer-example
+  datasource:
+    url: ${SPRING_DATASOURCE_URL:jdbc:postgresql://localhost:5432/opendaimon}
+    username: ${SPRING_DATASOURCE_USERNAME:postgres}
+    password: ${SPRING_DATASOURCE_PASSWORD:postgres}
+  jpa:
+    hibernate:
+      ddl-auto: validate
+    open-in-view: false
+  ai:
+    openai:
+      api-key: ${OPENROUTER_KEY:missing-openrouter-key}
+
+open-daimon:
+  rest:
+    enabled: true
+    access:
+      admin:
+        emails:
+          - ${OPENDAIMON_ADMIN_EMAIL:admin@example.com}
+      regular:
+        emails:
+          - ${OPENDAIMON_USER_EMAIL:user@example.com}
diff --git a/opendaimon-starter-consumer-example/src/test/java/io/github/ngirchev/opendaimon/example/OpenRouterRestContractManualIT.java b/opendaimon-starter-consumer-example/src/test/java/io/github/ngirchev/opendaimon/example/OpenRouterRestContractManualIT.java
new file mode 100644
index 00000000..a3c565b8
--- /dev/null
+++ b/opendaimon-starter-consumer-example/src/test/java/io/github/ngirchev/opendaimon/example/OpenRouterRestContractManualIT.java
@@ -0,0 +1,84 @@
+package io.github.ngirchev.opendaimon.example;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assumptions.assumeTrue;
+
+import java.nio.file.Path;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import io.github.ngirchev.dotenv.DotEnvLoader;
+import io.github.ngirchev.opendaimon.rest.dto.ChatRequestDto;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.EnabledIfSystemProperty;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.web.client.TestRestTemplate;
+import org.springframework.http.HttpStatus;
+import org.springframework.test.context.DynamicPropertyRegistry;
+import org.springframework.test.context.DynamicPropertySource;
+import org.springframework.util.StringUtils;
+import org.testcontainers.containers.PostgreSQLContainer;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+@Testcontainers
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+@Tag("manual")
+@EnabledIfSystemProperty(named = "manual.openrouter.rest-contract", matches = "true")
+class OpenRouterRestContractManualIT {
+
+    private static final String OPENROUTER_KEY = "OPENROUTER_KEY";
+    private static final String ADMIN_EMAIL = "admin@example.com";
+
+    @Container
+    static final PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:16-alpine");
+
+    static {
+        DotEnvLoader.loadDotEnv(Path.of("..", ".env"));
+        DotEnvLoader.loadDotEnv();
+    }
+
+    @Autowired
+    private TestRestTemplate restTemplate;
+
+    @DynamicPropertySource
+    static void registerProperties(DynamicPropertyRegistry registry) {
+        registry.add("spring.datasource.url", postgres::getJdbcUrl);
+        registry.add("spring.datasource.username", postgres::getUsername);
+        registry.add("spring.datasource.password", postgres::getPassword);
+        registry.add("spring.ai.openai.api-key", OpenRouterRestContractManualIT::openRouterKeyOrPlaceholder);
+    }
+
+    @Test
+    void restChatEndpointUsesRealOpenRouterProvider() {
+        assumeTrue(StringUtils.hasText(openRouterKey()), "OPENROUTER_KEY is required for the OpenRouter contract test");
+
+        var request = new ChatRequestDto(
+                "What is 2 + 2? Reply with only the digit 4.",
+                null,
+                null,
+                ADMIN_EMAIL);
+
+        var response = restTemplate.postForEntity("/api/v1/session", request, JsonNode.class);
+
+        assertThat(response.getStatusCode())
+                .as(() -> response.getBody() != null ? response.getBody().toPrettyString() : "empty response body")
+                .isEqualTo(HttpStatus.OK);
+        assertThat(response.getBody())
+                .isNotNull();
+        assertThat(response.getBody().path("sessionId").asText())
+                .isNotBlank();
+        assertThat(response.getBody().path("message").asText())
+                .contains("4");
+    }
+
+    private static String openRouterKeyOrPlaceholder() {
+        String key = openRouterKey();
+        return StringUtils.hasText(key) ? key : "missing-openrouter-key";
+    }
+
+    private static String openRouterKey() {
+        return DotEnvLoader.getEnv(OPENROUTER_KEY);
+    }
+}
diff --git a/opendaimon-starter-consumer-example/src/test/java/io/github/ngirchev/opendaimon/example/StarterConsumerApplicationContextIT.java b/opendaimon-starter-consumer-example/src/test/java/io/github/ngirchev/opendaimon/example/StarterConsumerApplicationContextIT.java
new file mode 100644
index 00000000..f030de27
--- /dev/null
+++ b/opendaimon-starter-consumer-example/src/test/java/io/github/ngirchev/opendaimon/example/StarterConsumerApplicationContextIT.java
@@ -0,0 +1,46 @@
+package io.github.ngirchev.opendaimon.example;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import io.github.ngirchev.opendaimon.common.meter.OpenDaimonMeterRegistry;
+import io.github.ngirchev.opendaimon.rest.controller.SessionController;
+import io.micrometer.core.instrument.MeterRegistry;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.context.ApplicationContext;
+import org.springframework.test.context.DynamicPropertyRegistry;
+import org.springframework.test.context.DynamicPropertySource;
+import org.testcontainers.containers.PostgreSQLContainer;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+@Testcontainers
+@SpringBootTest(
+        webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,
+        properties = "open-daimon.ai.spring-ai.mock=true")
+class StarterConsumerApplicationContextIT {
+
+    @Container
+    static final PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:16-alpine");
+
+    @Autowired
+    private ApplicationContext applicationContext;
+
+    @DynamicPropertySource
+    static void registerProperties(DynamicPropertyRegistry registry) {
+        registry.add("spring.datasource.url", postgres::getJdbcUrl);
+        registry.add("spring.datasource.username", postgres::getUsername);
+        registry.add("spring.datasource.password", postgres::getPassword);
+    }
+
+    @Test
+    void applicationContextStartsWithStarterRestAndMicrometerFallback() {
+        assertThat(applicationContext.getBean(MeterRegistry.class))
+                .isNotNull();
+        assertThat(applicationContext.getBean(OpenDaimonMeterRegistry.class))
+                .isNotNull();
+        assertThat(applicationContext.getBean(SessionController.class))
+                .isNotNull();
+    }
+}
diff --git a/opendaimon-starter-consumer-example/src/test/java/io/github/ngirchev/opendaimon/example/StarterConsumerClasspathSmokeTest.java b/opendaimon-starter-consumer-example/src/test/java/io/github/ngirchev/opendaimon/example/StarterConsumerClasspathSmokeTest.java
new file mode 100644
index 00000000..75b53907
--- /dev/null
+++ b/opendaimon-starter-consumer-example/src/test/java/io/github/ngirchev/opendaimon/example/StarterConsumerClasspathSmokeTest.java
@@ -0,0 +1,121 @@
+package io.github.ngirchev.opendaimon.example;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.xml.XMLConstants;
+import javax.xml.parsers.DocumentBuilderFactory;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.autoconfigure.AutoConfiguration;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.context.annotation.ImportCandidates;
+import org.springframework.boot.env.YamlPropertySourceLoader;
+import org.springframework.core.io.ClassPathResource;
+import org.w3c.dom.Element;
+
+class StarterConsumerClasspathSmokeTest {
+
+    @Test
+    void springBootDiscoversOpenDaimonAutoConfigurationsFromStarterDependency() {
+        var autoConfigurations = new ArrayList<String>();
+        for (String autoConfiguration : ImportCandidates.load(
+                AutoConfiguration.class,
+                StarterConsumerClasspathSmokeTest.class.getClassLoader())) {
+            autoConfigurations.add(autoConfiguration);
+        }
+
+        assertThat(autoConfigurations)
+                .contains(
+                        "io.github.ngirchev.opendaimon.common.config.CoreAutoConfig",
+                        "io.github.ngirchev.opendaimon.bulkhead.config.BulkHeadAutoConfig",
+                        "io.github.ngirchev.opendaimon.common.storage.config.StorageAutoConfig",
+                        "io.github.ngirchev.opendaimon.ai.springai.config.SpringAIAutoConfig",
+                        "io.github.ngirchev.opendaimon.ai.springai.config.RAGAutoConfig",
+                        "io.github.ngirchev.opendaimon.ai.springai.config.AgentAutoConfig",
+                        "io.github.ngirchev.opendaimon.rest.config.RestAutoConfig");
+    }
+
+    @Test
+    void exampleDeclaresStarterAndRestAsOnlyOpenDaimonDependencies() throws Exception {
+        assertThat(loadOpenDaimonDependencies())
+                .containsExactly(
+                        "opendaimon-spring-boot-starter",
+                        "opendaimon-rest");
+    }
+
+    @Test
+    void applicationUsesStandardSpringBootEntryPoint() {
+        assertThat(StarterConsumerApplication.class.getAnnotation(SpringBootApplication.class))
+                .isNotNull();
+    }
+
+    @Test
+    void starterClasspathIncludesFlywayPostgreSqlSupport() throws Exception {
+        assertThat(Class.forName("org.flywaydb.database.postgresql.PostgreSQLDatabaseType"))
+                .isNotNull();
+    }
+
+    @Test
+    void starterDefaultsAreAvailableFromConsumerClasspath() throws Exception {
+        var loader = new YamlPropertySourceLoader();
+        var starterDefaults = loader
+                .load(
+                        "opendaimon-defaults.yml",
+                        new ClassPathResource("META-INF/opendaimon/opendaimon-defaults.yml"))
+                .getFirst();
+
+        assertThat(starterDefaults.getProperty("open-daimon.ai.spring-ai.enabled"))
+                .isEqualTo(true);
+        assertThat(starterDefaults.containsProperty("open-daimon.rest.enabled"))
+                .isFalse();
+        assertThat(starterDefaults.getProperty("spring.ai.openai.base-url"))
+                .isEqualTo("https://openrouter.ai/api");
+        assertThat(starterDefaults.getProperty("open-daimon.ai.spring-ai.models.list[0].provider-type"))
+                .isEqualTo("${OPENDAIMON_DEFAULT_PROVIDER:OPENAI}");
+    }
+
+    @Test
+    void exampleApplicationExplicitlyEnablesRestModule() throws Exception {
+        var loader = new YamlPropertySourceLoader();
+        var application = loader
+                .load(
+                        "application.yml",
+                        new ClassPathResource("application.yml"))
+                .getFirst();
+
+        assertThat(application.getProperty("open-daimon.rest.enabled"))
+                .isEqualTo(true);
+    }
+
+    private List<String> loadOpenDaimonDependencies() throws Exception {
+        var factory = DocumentBuilderFactory.newInstance();
+        factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
+
+        var document = factory.newDocumentBuilder()
+                .parse(Path.of("pom.xml").toFile());
+        var dependencies = document.getElementsByTagName("dependency");
+        var openDaimonDependencies = new ArrayList<String>();
+
+        for (int i = 0; i < dependencies.getLength(); i++) {
+            Element dependency = (Element) dependencies.item(i);
+            String artifactId = textOf(dependency, "artifactId");
+            if ("io.github.ngirchev".equals(textOf(dependency, "groupId"))
+                    && artifactId.startsWith("opendaimon-")) {
+                openDaimonDependencies.add(artifactId);
+            }
+        }
+
+        return openDaimonDependencies;
+    }
+
+    private String textOf(Element element, String tagName) {
+        return element.getElementsByTagName(tagName)
+                .item(0)
+                .getTextContent()
+                .trim();
+    }
+}
diff --git a/opendaimon-telegram/TELEGRAM_MODULE.md b/opendaimon-telegram/TELEGRAM_MODULE.md
index 36bdc108..58b625fc 100644
--- a/opendaimon-telegram/TELEGRAM_MODULE.md
+++ b/opendaimon-telegram/TELEGRAM_MODULE.md
@@ -559,7 +559,7 @@ Both messages are sent as replies to the original user message.
      such as a missing web-search query are compacted for the user while the
      full observation remains available to the agent loop.
 5. `MAX_ITERATIONS`: model confirms the terminal output first, strips any trailing partial-answer overlay from status, then appends `⚠️ reached iteration limit`.
-6. `FINAL_ANSWER` (or terminal max-iterations fallback): model confirms final answer and the view creates/edits answer message. The trailing partial-answer overlay (when a candidate was actually rendered as the status tail) is stripped from `statusHtml` so the status message does not freeze with a stale fragment (e.g. `<i>На ос</i>`) next to the freshly delivered answer. In `HIDE_REASONING`, a trailing reasoning overlay is also removed on confirmation; in `SHOW_ALL`, reasoning overlays are preserved. If the overlay was the only status content, it is replaced with a `✅` marker because Telegram rejects empty edits.
+6. `FINAL_ANSWER` (or terminal max-iterations fallback): model confirms final answer and the view creates/edits answer message. The trailing partial-answer overlay (when a candidate was actually rendered as the status tail) is stripped from `statusHtml` so the status message does not freeze with a stale fragment (e.g. `<i>На ос</i>`) next to the freshly delivered answer. In `HIDE_REASONING`, a trailing reasoning overlay is also removed on confirmation; in `SHOW_ALL`, reasoning overlays are preserved. If the overlay was the only status content, it is replaced with `✅ Done` because Telegram rejects empty edits and renders lone emoji as oversized messages.
 
 ### Thinking modes
 
@@ -600,8 +600,9 @@ answer.
 ### Length handling
 
 - status message rotation uses `TelegramProgressBatcher.selectContentToFlush(...)`
-- final answer uses chunked send when text exceeds `maxMessageLength`
-- split prefers paragraph boundaries; oversized paragraphs are hard-cut to stay within Telegram limits
+- final answer uses chunked send when the converted Telegram HTML would exceed `maxMessageLength`
+- split prefers paragraph boundaries, flushes the current paragraph buffer before overflow,
+  and hard-cuts oversized paragraphs so every sent HTML chunk stays within Telegram limits
 
 ---
 
diff --git a/opendaimon-telegram/pom.xml b/opendaimon-telegram/pom.xml
index d0aed65e..ded6ca3f 100644
--- a/opendaimon-telegram/pom.xml
+++ b/opendaimon-telegram/pom.xml
@@ -36,6 +36,10 @@
             <artifactId>opendaimon-common</artifactId>
             <version>${project.version}</version>
         </dependency>
+        <dependency>
+            <groupId>io.github.ngirchev</groupId>
+            <artifactId>fsm</artifactId>
+        </dependency>
 
         <!-- Telegram -->
         <dependency>
@@ -47,53 +51,238 @@
                     <artifactId>jackson-module-jaxb-annotations</artifactId>
                 </exclusion>
             </exclusions>
-            <version>${telegram.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.telegram</groupId>
+            <artifactId>telegrambots-meta</artifactId>
+        </dependency>
+        <!-- Apache HttpClient (legacy, used by Telegram SDK API surfaces directly) -->
+        <dependency>
+            <groupId>org.apache.httpcomponents</groupId>
+            <artifactId>httpclient</artifactId>
+        </dependency>
+
+        <!-- Spring Framework leaves -->
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-core</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-beans</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-context</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-tx</artifactId>
         </dependency>
 
+        <!-- Spring Boot core -->
         <dependency>
             <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-autoconfigure</artifactId>
+            <artifactId>spring-boot</artifactId>
         </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-data-redis</artifactId>
+            <artifactId>spring-boot-autoconfigure</artifactId>
+        </dependency>
+
+        <!-- Spring Data -->
+        <dependency>
+            <groupId>org.springframework.data</groupId>
+            <artifactId>spring-data-commons</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.data</groupId>
+            <artifactId>spring-data-jpa</artifactId>
+        </dependency>
+        <!-- Spring Data Redis (optional - alternative cache backend) -->
+        <dependency>
+            <groupId>org.springframework.data</groupId>
+            <artifactId>spring-data-redis</artifactId>
             <optional>true</optional>
         </dependency>
+
+        <!-- Spring AI (TelegramBot bridges spring-ai message types) -->
+        <dependency>
+            <groupId>org.springframework.ai</groupId>
+            <artifactId>spring-ai-model</artifactId>
+        </dependency>
+
+        <!-- Reactor (streaming AI responses) -->
+        <dependency>
+            <groupId>io.projectreactor</groupId>
+            <artifactId>reactor-core</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.reactivestreams</groupId>
+            <artifactId>reactive-streams</artifactId>
+        </dependency>
+
+        <!-- JPA / Persistence -->
+        <dependency>
+            <groupId>jakarta.persistence</groupId>
+            <artifactId>jakarta.persistence-api</artifactId>
+        </dependency>
+
+        <!-- Validation -->
+        <dependency>
+            <groupId>jakarta.validation</groupId>
+            <artifactId>jakarta.validation-api</artifactId>
+        </dependency>
+
+        <!-- Annotations -->
+        <dependency>
+            <groupId>jakarta.annotation</groupId>
+            <artifactId>jakarta.annotation-api</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.jetbrains</groupId>
+            <artifactId>annotations</artifactId>
+        </dependency>
+
+        <!-- Database / Flyway core for module migrations -->
         <dependency>
             <groupId>org.flywaydb</groupId>
             <artifactId>flyway-core</artifactId>
         </dependency>
+
+        <!-- Logging -->
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
+        </dependency>
+
+        <!-- Lombok: compile-only annotation processor -->
         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>
+            <scope>provided</scope>
             <optional>true</optional>
         </dependency>
 
+        <!-- Jackson -->
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-core</artifactId>
+        </dependency>
+
+        <!-- Apache Commons Lang3 (StringUtils etc.) -->
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+        </dependency>
+
+        <!-- Caffeine cache (TelegramChatPacerImpl) -->
+        <dependency>
+            <groupId>com.github.ben-manes.caffeine</groupId>
+            <artifactId>caffeine</artifactId>
+        </dependency>
+
         <!-- Test -->
+        <!-- Micrometer (only test code uses MeterRegistry directly) -->
+        <dependency>
+            <groupId>io.micrometer</groupId>
+            <artifactId>micrometer-core</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-test</artifactId>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-test</artifactId>
+            <artifactId>spring-boot-test</artifactId>
             <scope>test</scope>
         </dependency>
         <dependency>
-            <groupId>org.flywaydb</groupId>
-            <artifactId>flyway-database-postgresql</artifactId>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
             <scope>test</scope>
         </dependency>
         <dependency>
-            <groupId>org.testcontainers</groupId>
-            <artifactId>testcontainers</artifactId>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-engine</artifactId>
             <scope>test</scope>
         </dependency>
         <dependency>
-            <groupId>org.testcontainers</groupId>
-            <artifactId>postgresql</artifactId>
+            <groupId>com.tngtech.archunit</groupId>
+            <artifactId>archunit</artifactId>
+            <version>${archunit.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.tngtech.archunit</groupId>
+            <artifactId>archunit-junit5-api</artifactId>
+            <version>${archunit.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.tngtech.archunit</groupId>
+            <artifactId>archunit-junit5-engine</artifactId>
+            <version>${archunit.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-junit-jupiter</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
             <scope>test</scope>
         </dependency>
         <dependency>
             <groupId>org.testcontainers</groupId>
-            <artifactId>junit-jupiter</artifactId>
+            <artifactId>postgresql</artifactId>
             <scope>test</scope>
         </dependency>
     </dependencies>
-</project> 
\ No newline at end of file
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-dependency-plugin</artifactId>
+                <configuration>
+                    <ignoredUnusedDeclaredDependencies>
+                        <!-- JUnit Jupiter engine is required by IDE/JUnit Platform runtime discovery;
+                             test classes import only the API. -->
+                        <ignored>org.junit.jupiter:junit-jupiter-engine</ignored>
+                        <!-- ArchUnit JUnit engine is discovered by JUnit Platform at runtime;
+                             no test class imports it directly. -->
+                        <ignored>com.tngtech.archunit:archunit-junit5-engine</ignored>
+                    </ignoredUnusedDeclaredDependencies>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-enforcer-plugin</artifactId>
+                <configuration>
+                    <rules>
+                        <bannedDependencies>
+                            <searchTransitive>true</searchTransitive>
+                            <excludes>
+                                <exclude>org.springframework.boot:spring-boot-starter*</exclude>
+                            </excludes>
+                        </bannedDependencies>
+                    </rules>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>
diff --git a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/TelegramSupportedCommandProvider.java b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/TelegramSupportedCommandProvider.java
similarity index 87%
rename from opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/TelegramSupportedCommandProvider.java
rename to opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/TelegramSupportedCommandProvider.java
index eff108b5..bb89d5a5 100644
--- a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/TelegramSupportedCommandProvider.java
+++ b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/TelegramSupportedCommandProvider.java
@@ -1,4 +1,4 @@
-package io.github.ngirchev.opendaimon.telegram.command.handler;
+package io.github.ngirchev.opendaimon.telegram.command;
 
 /**
  * Marker interface for handlers that can provide the description of their supported command
@@ -12,5 +12,3 @@ public interface TelegramSupportedCommandProvider {
      */
     String getSupportedCommandText(String languageCode);
 }
-
-
diff --git a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/AbstractTelegramCommandHandler.java b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/AbstractTelegramCommandHandler.java
index 7ff8dec1..1883db41 100644
--- a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/AbstractTelegramCommandHandler.java
+++ b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/AbstractTelegramCommandHandler.java
@@ -12,6 +12,7 @@
 import io.github.ngirchev.opendaimon.telegram.TelegramBot;
 import io.github.ngirchev.opendaimon.telegram.command.TelegramCommand;
 import io.github.ngirchev.opendaimon.telegram.command.TelegramCommandType;
+import io.github.ngirchev.opendaimon.telegram.command.TelegramSupportedCommandProvider;
 import io.github.ngirchev.opendaimon.telegram.service.TypingIndicatorService;
 
 @Slf4j
diff --git a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/AbstractTelegramCommandHandlerWithResponseSend.java b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/AbstractTelegramCommandHandlerWithResponseSend.java
index 91ba9b9b..d95bc3ea 100644
--- a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/AbstractTelegramCommandHandlerWithResponseSend.java
+++ b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/AbstractTelegramCommandHandlerWithResponseSend.java
@@ -14,6 +14,7 @@
 import io.github.ngirchev.opendaimon.telegram.TelegramBot;
 import io.github.ngirchev.opendaimon.telegram.command.TelegramCommand;
 import io.github.ngirchev.opendaimon.telegram.command.TelegramCommandType;
+import io.github.ngirchev.opendaimon.telegram.command.TelegramSupportedCommandProvider;
 import io.github.ngirchev.opendaimon.telegram.service.TypingIndicatorService;
 
 @Slf4j
diff --git a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/BackoffCommandHandler.java b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/BackoffCommandHandler.java
index a1899a06..4f507c08 100644
--- a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/BackoffCommandHandler.java
+++ b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/BackoffCommandHandler.java
@@ -8,7 +8,7 @@
 import io.github.ngirchev.opendaimon.telegram.command.TelegramCommandType;
 import io.github.ngirchev.opendaimon.common.service.MessageLocalizationService;
 import io.github.ngirchev.opendaimon.telegram.command.handler.AbstractTelegramCommandHandlerWithResponseSend;
-import io.github.ngirchev.opendaimon.telegram.command.handler.TelegramSupportedCommandProvider;
+import io.github.ngirchev.opendaimon.telegram.command.TelegramSupportedCommandProvider;
 import io.github.ngirchev.opendaimon.telegram.service.TypingIndicatorService;
 
 import java.util.Objects;
diff --git a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/HistoryTelegramCommandHandler.java b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/HistoryTelegramCommandHandler.java
index 3102fa0b..e6cfd605 100644
--- a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/HistoryTelegramCommandHandler.java
+++ b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/HistoryTelegramCommandHandler.java
@@ -7,9 +7,9 @@
 import io.github.ngirchev.opendaimon.common.model.OpenDaimonMessage;
 import io.github.ngirchev.opendaimon.common.model.MessageRole;
 import io.github.ngirchev.opendaimon.common.model.ThreadScopeKind;
-import io.github.ngirchev.opendaimon.common.repository.ConversationThreadRepository;
-import io.github.ngirchev.opendaimon.common.repository.OpenDaimonMessageRepository;
+import io.github.ngirchev.opendaimon.common.service.ConversationThreadService;
 import io.github.ngirchev.opendaimon.common.service.MessageLocalizationService;
+import io.github.ngirchev.opendaimon.common.service.OpenDaimonMessageService;
 import io.github.ngirchev.opendaimon.telegram.TelegramBot;
 import io.github.ngirchev.opendaimon.telegram.command.TelegramCommand;
 import io.github.ngirchev.opendaimon.telegram.command.TelegramCommandType;
@@ -28,20 +28,20 @@
 @Slf4j
 public class HistoryTelegramCommandHandler extends AbstractTelegramCommandHandlerWithResponseSend {
     
-    private final ConversationThreadRepository threadRepository;
-    private final OpenDaimonMessageRepository messageRepository;
+    private final ConversationThreadService threadService;
+    private final OpenDaimonMessageService messageService;
     private final TelegramUserService userService;
     
     public HistoryTelegramCommandHandler(
             ObjectProvider<TelegramBot> telegramBotProvider,
             TypingIndicatorService typingIndicatorService,
             MessageLocalizationService messageLocalizationService,
-            ConversationThreadRepository threadRepository,
-            OpenDaimonMessageRepository messageRepository,
+            ConversationThreadService threadService,
+            OpenDaimonMessageService messageService,
             TelegramUserService userService) {
         super(telegramBotProvider, typingIndicatorService, messageLocalizationService);
-        this.threadRepository = threadRepository;
-        this.messageRepository = messageRepository;
+        this.threadService = threadService;
+        this.messageService = messageService;
         this.userService = userService;
     }
     
@@ -65,13 +65,13 @@ public String handleInner(TelegramCommand command) throws TelegramCommandHandler
             throw new TelegramCommandHandlerException(command.telegramId(), "Message is required for history command");
         }
         userService.getOrCreateUser(message.getFrom());
-        Optional<ConversationThread> threadOpt = threadRepository.findMostRecentActiveThread(
+        Optional<ConversationThread> threadOpt = threadService.findCurrentThread(
                 ThreadScopeKind.TELEGRAM_CHAT, command.telegramId());
         if (threadOpt.isEmpty()) {
             return "❌ You have no active conversation. Start one by sending a message.";
         }
         ConversationThread thread = threadOpt.get();
-        List<OpenDaimonMessage> messages = messageRepository.findByThreadOrderBySequenceNumberAsc(thread);
+        List<OpenDaimonMessage> messages = messageService.findByThreadOrderBySequenceNumberAsc(thread);
         if (messages.isEmpty()) {
             return "📝 Conversation history is empty.\n\nThread ID: `" + thread.getThreadKey().substring(0, 8) + "...`";
         }
diff --git a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/MessageTelegramCommandHandler.java b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/MessageTelegramCommandHandler.java
index 68c49dcf..3c7a2fe9 100644
--- a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/MessageTelegramCommandHandler.java
+++ b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/MessageTelegramCommandHandler.java
@@ -19,10 +19,10 @@
 import io.github.ngirchev.opendaimon.telegram.command.TelegramCommandType;
 import io.github.ngirchev.opendaimon.telegram.command.handler.AbstractTelegramCommandHandler;
 import io.github.ngirchev.opendaimon.telegram.command.handler.AbstractTelegramCommandHandlerWithResponseSend;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerContext;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerErrorType;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerEvent;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerState;
+import io.github.ngirchev.opendaimon.telegram.service.fsm.MessageHandlerContext;
+import io.github.ngirchev.opendaimon.telegram.service.fsm.MessageHandlerErrorType;
+import io.github.ngirchev.opendaimon.telegram.service.fsm.MessageHandlerEvent;
+import io.github.ngirchev.opendaimon.telegram.service.fsm.MessageHandlerState;
 import io.github.ngirchev.opendaimon.telegram.config.TelegramProperties;
 import io.github.ngirchev.opendaimon.telegram.model.TelegramUser;
 import io.github.ngirchev.opendaimon.telegram.service.PersistentKeyboardService;
diff --git a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/NewThreadTelegramCommandHandler.java b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/NewThreadTelegramCommandHandler.java
index 560c3538..4bd9c0df 100644
--- a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/NewThreadTelegramCommandHandler.java
+++ b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/NewThreadTelegramCommandHandler.java
@@ -6,7 +6,6 @@
 import io.github.ngirchev.opendaimon.common.command.ICommand;
 import io.github.ngirchev.opendaimon.common.model.ConversationThread;
 import io.github.ngirchev.opendaimon.common.model.ThreadScopeKind;
-import io.github.ngirchev.opendaimon.common.repository.ConversationThreadRepository;
 import io.github.ngirchev.opendaimon.common.service.ConversationThreadService;
 import io.github.ngirchev.opendaimon.common.service.MessageLocalizationService;
 import io.github.ngirchev.opendaimon.telegram.TelegramBot;
@@ -19,8 +18,6 @@
 import io.github.ngirchev.opendaimon.telegram.service.TelegramUserService;
 import io.github.ngirchev.opendaimon.telegram.service.TypingIndicatorService;
 
-import java.util.Optional;
-
 /**
  * Handler for /newthread command to start a new conversation.
  */
@@ -28,7 +25,6 @@
 public class NewThreadTelegramCommandHandler extends AbstractTelegramCommandHandlerWithResponseSend {
     
     private final ConversationThreadService threadService;
-    private final ConversationThreadRepository threadRepository;
     private final TelegramUserService userService;
     private final ObjectProvider<PersistentKeyboardService> persistentKeyboardServiceProvider;
 
@@ -37,12 +33,10 @@ public NewThreadTelegramCommandHandler(
             TypingIndicatorService typingIndicatorService,
             MessageLocalizationService messageLocalizationService,
             ConversationThreadService threadService,
-            ConversationThreadRepository threadRepository,
             TelegramUserService userService,
             ObjectProvider<PersistentKeyboardService> persistentKeyboardServiceProvider) {
         super(telegramBotProvider, typingIndicatorService, messageLocalizationService);
         this.threadService = threadService;
-        this.threadRepository = threadRepository;
         this.userService = userService;
         this.persistentKeyboardServiceProvider = persistentKeyboardServiceProvider;
     }
@@ -72,10 +66,7 @@ public String handleInner(TelegramCommand command) throws TelegramCommandHandler
         Long chatId = command.telegramId();
 
         // Close current thread (if any active)
-        Optional<ConversationThread> currentThread = threadRepository.findMostRecentActiveThread(
-                ThreadScopeKind.TELEGRAM_CHAT, chatId);
-        boolean hadPreviousThread = currentThread.isPresent();
-        currentThread.ifPresent(threadService::closeThread);
+        boolean hadPreviousThread = threadService.closeCurrentThread(ThreadScopeKind.TELEGRAM_CHAT, chatId);
 
         // Create new thread — thread.user is the invoker (audit), scope is per-chat.
         ConversationThread newThread = threadService.createNewThread(user, ThreadScopeKind.TELEGRAM_CHAT, chatId);
diff --git a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/StartTelegramCommandHandler.java b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/StartTelegramCommandHandler.java
index 81621397..3e951d6f 100644
--- a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/StartTelegramCommandHandler.java
+++ b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/StartTelegramCommandHandler.java
@@ -7,7 +7,7 @@
 import io.github.ngirchev.opendaimon.telegram.command.TelegramCommandType;
 import io.github.ngirchev.opendaimon.common.service.MessageLocalizationService;
 import io.github.ngirchev.opendaimon.telegram.command.handler.AbstractTelegramCommandHandlerWithResponseSend;
-import io.github.ngirchev.opendaimon.telegram.command.handler.TelegramSupportedCommandProvider;
+import io.github.ngirchev.opendaimon.telegram.command.TelegramSupportedCommandProvider;
 import io.github.ngirchev.opendaimon.telegram.service.TypingIndicatorService;
 
 import java.util.Objects;
diff --git a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/ThreadsTelegramCommandHandler.java b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/ThreadsTelegramCommandHandler.java
index 72bb2f9e..358be1ae 100644
--- a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/ThreadsTelegramCommandHandler.java
+++ b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/ThreadsTelegramCommandHandler.java
@@ -13,7 +13,6 @@
 import io.github.ngirchev.opendaimon.common.command.ICommand;
 import io.github.ngirchev.opendaimon.common.model.ConversationThread;
 import io.github.ngirchev.opendaimon.common.model.ThreadScopeKind;
-import io.github.ngirchev.opendaimon.common.repository.ConversationThreadRepository;
 import io.github.ngirchev.opendaimon.common.service.ConversationThreadService;
 import io.github.ngirchev.opendaimon.common.service.MessageLocalizationService;
 import io.github.ngirchev.opendaimon.telegram.TelegramBot;
@@ -38,7 +37,6 @@ public class ThreadsTelegramCommandHandler extends AbstractTelegramCommandHandle
     private static final String CALLBACK_PREFIX = "THREADS_";
     private static final String CALLBACK_CANCEL = CALLBACK_PREFIX + "CANCEL";
 
-    private final ConversationThreadRepository threadRepository;
     private final ConversationThreadService threadService;
     private final TelegramUserService userService;
 
@@ -46,11 +44,9 @@ public ThreadsTelegramCommandHandler(
             ObjectProvider<TelegramBot> telegramBotProvider,
             TypingIndicatorService typingIndicatorService,
             MessageLocalizationService messageLocalizationService,
-            ConversationThreadRepository threadRepository,
             ConversationThreadService threadService,
             TelegramUserService userService) {
         super(telegramBotProvider, typingIndicatorService, messageLocalizationService);
-        this.threadRepository = threadRepository;
         this.threadService = threadService;
         this.userService = userService;
     }
@@ -103,8 +99,7 @@ public String handleInner(TelegramCommand command) throws TelegramCommandHandler
         String lang = command.languageCode();
 
         // Get all threads (active and inactive)
-        List<ConversationThread> allThreads = threadRepository.findByScopeKindAndScopeIdOrderByLastActivityAtDesc(
-                ThreadScopeKind.TELEGRAM_CHAT, chatId);
+        List<ConversationThread> allThreads = threadService.findThreads(ThreadScopeKind.TELEGRAM_CHAT, chatId);
 
         if (allThreads.isEmpty()) {
             return messageLocalizationService.getMessage("telegram.threads.empty", lang);
@@ -203,8 +198,7 @@ private void handleCallbackQuery(TelegramCommand command) throws TelegramCommand
     private void sendMessageWithMenu(Long chatId, String text, TelegramCommand command, String lang) throws TelegramCommandHandlerException {
         try {
             userService.getOrCreateUser(command.update().getMessage().getFrom());
-            List<ConversationThread> allThreads = threadRepository.findByScopeKindAndScopeIdOrderByLastActivityAtDesc(
-                    ThreadScopeKind.TELEGRAM_CHAT, chatId);
+            List<ConversationThread> allThreads = threadService.findThreads(ThreadScopeKind.TELEGRAM_CHAT, chatId);
 
             if (allThreads.isEmpty()) {
                 sendMessage(chatId, text);
diff --git a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/config/TelegramCommandHandlerConfig.java b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/config/TelegramCommandHandlerConfig.java
index 10fb14e6..88a39310 100644
--- a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/config/TelegramCommandHandlerConfig.java
+++ b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/config/TelegramCommandHandlerConfig.java
@@ -14,19 +14,18 @@
 import io.github.ngirchev.opendaimon.common.agent.AgentExecutor;
 import io.github.ngirchev.opendaimon.common.ai.pipeline.AIRequestPipeline;
 import io.github.ngirchev.opendaimon.common.config.CoreCommonProperties;
-import io.github.ngirchev.opendaimon.common.repository.ConversationThreadRepository;
 import io.github.ngirchev.opendaimon.common.repository.OpenDaimonMessageRepository;
 import io.github.ngirchev.opendaimon.common.service.*;
 import io.github.ngirchev.opendaimon.telegram.TelegramBot;
-import io.github.ngirchev.opendaimon.telegram.command.handler.TelegramSupportedCommandProvider;
+import io.github.ngirchev.opendaimon.telegram.command.TelegramSupportedCommandProvider;
 import io.github.ngirchev.opendaimon.telegram.command.handler.impl.*;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerActions;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerContext;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerEvent;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerFsmFactory;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerState;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.TelegramMessageHandlerActions;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.TelegramMessageSender;
+import io.github.ngirchev.opendaimon.telegram.service.fsm.MessageHandlerActions;
+import io.github.ngirchev.opendaimon.telegram.service.fsm.MessageHandlerContext;
+import io.github.ngirchev.opendaimon.telegram.service.fsm.MessageHandlerEvent;
+import io.github.ngirchev.opendaimon.telegram.service.fsm.MessageHandlerFsmFactory;
+import io.github.ngirchev.opendaimon.telegram.service.fsm.MessageHandlerState;
+import io.github.ngirchev.opendaimon.telegram.service.fsm.TelegramMessageHandlerActions;
+import io.github.ngirchev.opendaimon.telegram.service.TelegramMessageSender;
 import io.github.ngirchev.opendaimon.telegram.service.ChatSettingsService;
 import io.github.ngirchev.opendaimon.telegram.service.InMemoryModelSelectionSession;
 import io.github.ngirchev.opendaimon.telegram.service.ModelSelectionSession;
@@ -151,7 +150,6 @@ public NewThreadTelegramCommandHandler newThreadTelegramCommandHandler(
             TypingIndicatorService typingIndicatorService,
             MessageLocalizationService messageLocalizationService,
             ConversationThreadService threadService,
-            ConversationThreadRepository threadRepository,
             TelegramUserService telegramUserService,
             ObjectProvider<PersistentKeyboardService> persistentKeyboardServiceProvider) {
         return new NewThreadTelegramCommandHandler(
@@ -159,7 +157,6 @@ public NewThreadTelegramCommandHandler newThreadTelegramCommandHandler(
                 typingIndicatorService,
                 messageLocalizationService,
                 threadService,
-                threadRepository,
                 telegramUserService,
                 persistentKeyboardServiceProvider);
     }
@@ -171,15 +168,15 @@ public HistoryTelegramCommandHandler historyTelegramCommandHandler(
             ObjectProvider<TelegramBot> telegramBotProvider,
             TypingIndicatorService typingIndicatorService,
             MessageLocalizationService messageLocalizationService,
-            ConversationThreadRepository threadRepository,
-            OpenDaimonMessageRepository messageRepository,
+            ConversationThreadService threadService,
+            OpenDaimonMessageService messageService,
             TelegramUserService telegramUserService) {
         return new HistoryTelegramCommandHandler(
                 telegramBotProvider,
                 typingIndicatorService,
                 messageLocalizationService,
-                threadRepository,
-                messageRepository,
+                threadService,
+                messageService,
                 telegramUserService);
     }
 
@@ -190,14 +187,12 @@ public ThreadsTelegramCommandHandler threadsTelegramCommandHandler(
             ObjectProvider<TelegramBot> telegramBotProvider,
             TypingIndicatorService typingIndicatorService,
             MessageLocalizationService messageLocalizationService,
-            ConversationThreadRepository threadRepository,
             ConversationThreadService threadService,
             TelegramUserService telegramUserService) {
         return new ThreadsTelegramCommandHandler(
                 telegramBotProvider,
                 typingIndicatorService,
                 messageLocalizationService,
-                threadRepository,
                 threadService,
                 telegramUserService);
     }
diff --git a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/config/TelegramServiceConfig.java b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/config/TelegramServiceConfig.java
index 9c306a54..20cfc3c8 100644
--- a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/config/TelegramServiceConfig.java
+++ b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/config/TelegramServiceConfig.java
@@ -25,7 +25,7 @@
 import io.github.ngirchev.opendaimon.common.storage.config.StorageProperties;
 import io.github.ngirchev.opendaimon.common.storage.service.FileStorageService;
 import io.github.ngirchev.opendaimon.telegram.TelegramBot;
-import io.github.ngirchev.opendaimon.telegram.command.handler.TelegramSupportedCommandProvider;
+import io.github.ngirchev.opendaimon.telegram.command.TelegramSupportedCommandProvider;
 import io.github.ngirchev.opendaimon.telegram.repository.TelegramGroupRepository;
 import io.github.ngirchev.opendaimon.telegram.repository.TelegramUserRepository;
 import io.github.ngirchev.opendaimon.telegram.repository.TelegramUserSessionRepository;
diff --git a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/repository/TelegramGroupRepository.java b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/repository/TelegramGroupRepository.java
index 857e9575..855051ac 100644
--- a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/repository/TelegramGroupRepository.java
+++ b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/repository/TelegramGroupRepository.java
@@ -1,12 +1,10 @@
 package io.github.ngirchev.opendaimon.telegram.repository;
 
 import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
 import io.github.ngirchev.opendaimon.telegram.model.TelegramGroup;
 
 import java.util.Optional;
 
-@Repository
 public interface TelegramGroupRepository extends JpaRepository<TelegramGroup, Long> {
 
     Optional<TelegramGroup> findByTelegramId(Long telegramId);
diff --git a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/repository/TelegramUserRepository.java b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/repository/TelegramUserRepository.java
index b5dde696..8c0a6f61 100644
--- a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/repository/TelegramUserRepository.java
+++ b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/repository/TelegramUserRepository.java
@@ -1,12 +1,10 @@
 package io.github.ngirchev.opendaimon.telegram.repository;
 
 import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
 import io.github.ngirchev.opendaimon.telegram.model.TelegramUser;
 
 import java.util.Optional;
 
-@Repository
 public interface TelegramUserRepository extends JpaRepository<TelegramUser, Long> {
     
     Optional<TelegramUser> findByTelegramId(Long telegramId);
diff --git a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/repository/TelegramUserSessionRepository.java b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/repository/TelegramUserSessionRepository.java
index da0128c6..3ce1aff2 100644
--- a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/repository/TelegramUserSessionRepository.java
+++ b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/repository/TelegramUserSessionRepository.java
@@ -5,7 +5,6 @@
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.query.Param;
-import org.springframework.stereotype.Repository;
 import io.github.ngirchev.opendaimon.telegram.model.TelegramUser;
 import io.github.ngirchev.opendaimon.telegram.model.TelegramUserSession;
 
@@ -13,7 +12,6 @@
 import java.util.List;
 import java.util.Optional;
 
-@Repository
 public interface TelegramUserSessionRepository extends JpaRepository<TelegramUserSession, Long> {
     
     Optional<TelegramUserSession> findByTelegramUserAndSessionId(TelegramUser telegramUser, String sessionId);
diff --git a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/repository/TelegramWhitelistRepository.java b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/repository/TelegramWhitelistRepository.java
index 3bcd877a..b2554f52 100644
--- a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/repository/TelegramWhitelistRepository.java
+++ b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/repository/TelegramWhitelistRepository.java
@@ -3,13 +3,11 @@
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.query.Param;
-import org.springframework.stereotype.Repository;
 import io.github.ngirchev.opendaimon.telegram.model.TelegramUser;
 import io.github.ngirchev.opendaimon.telegram.model.TelegramWhitelist;
 
 import java.util.List;
 
-@Repository
 public interface TelegramWhitelistRepository extends JpaRepository<TelegramWhitelist, Long> {
     @Query("SELECT COUNT(w) > 0 FROM TelegramWhitelist w WHERE w.user.id = :userId")
     boolean existsByUserId(@Param("userId") Long userId);
diff --git a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/TelegramAgentStreamModel.java b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/TelegramAgentStreamModel.java
index 78897cc2..52eaadfa 100644
--- a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/TelegramAgentStreamModel.java
+++ b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/TelegramAgentStreamModel.java
@@ -20,6 +20,7 @@ public final class TelegramAgentStreamModel {
 
     public static final String STATUS_THINKING_LINE = "💭 Thinking...";
     public static final String STATUS_MAX_ITER_LINE = "⚠️ reached iteration limit";
+    public static final String STATUS_DONE_LINE = "✅ Done";
 
     private static final int CANDIDATE_TAIL_LIMIT = 400;
     private static final String MISSING_TOOL_ARGUMENT = "missing";
@@ -232,10 +233,10 @@ private void clearTrailingStatusOverlay() {
         if (lastBoundary >= 0) {
             statusHtml.setLength(lastBoundary);
         } else {
-            // Overlay was the only content; Telegram rejects empty edits, so leave a
-            // minimal completion marker.
+            // Overlay was the only content; Telegram rejects empty edits, so leave
+            // text next to the emoji to avoid Telegram's oversized single-emoji render.
             statusHtml.setLength(0);
-            statusHtml.append("✅");
+            statusHtml.append(STATUS_DONE_LINE);
         }
         statusDirty = true;
     }
diff --git a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/TelegramAgentStreamRenderer.java b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/TelegramAgentStreamRenderer.java
index 97ccac9f..4ee8d1c7 100644
--- a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/TelegramAgentStreamRenderer.java
+++ b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/TelegramAgentStreamRenderer.java
@@ -5,7 +5,7 @@
 import com.fasterxml.jackson.databind.ObjectMapper;
 import io.github.ngirchev.opendaimon.common.agent.AgentStreamEvent;
 import io.github.ngirchev.opendaimon.common.model.ThinkingMode;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerContext;
+import io.github.ngirchev.opendaimon.telegram.service.fsm.MessageHandlerContext;
 import io.github.ngirchev.opendaimon.telegram.model.TelegramUser;
 import lombok.RequiredArgsConstructor;
 
diff --git a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/TelegramAgentStreamView.java b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/TelegramAgentStreamView.java
index 3e1f9b68..91562fac 100644
--- a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/TelegramAgentStreamView.java
+++ b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/TelegramAgentStreamView.java
@@ -1,11 +1,14 @@
 package io.github.ngirchev.opendaimon.telegram.service;
 
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerContext;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.TelegramMessageSender;
+import io.github.ngirchev.opendaimon.telegram.service.fsm.MessageHandlerContext;
+import io.github.ngirchev.opendaimon.telegram.service.TelegramMessageSender;
 import io.github.ngirchev.opendaimon.telegram.config.TelegramProperties;
 import io.github.ngirchev.opendaimon.common.service.AIUtils;
 import lombok.extern.slf4j.Slf4j;
 
+import java.util.ArrayList;
+import java.util.List;
+
 /**
  * Telegram view for an agent stream model.
  *
@@ -129,29 +132,52 @@ private boolean flushAnswer(MessageHandlerContext ctx, TelegramAgentStreamModel
             return true;
         }
         Long chatId = ctx.getCommand().telegramId();
-        String html = model.answerHtml();
         long maxWaitMs = telegramProperties.getAgentStreamView().getFinalDeliveryTimeoutMs();
+        List<String> answerChunks = splitAnswerChunks(model.answerText());
+        if (answerChunks.isEmpty()) {
+            log.error("Final Telegram answer split produced no chunks for chatId={}", chatId);
+            return false;
+        }
         Integer answerId = ctx.getTentativeAnswerMessageId();
         if (answerId == null) {
             Integer replyTo = ctx.getMessage() != null ? ctx.getMessage().getMessageId() : null;
-            Integer sentId = sendAnswerChunks(chatId, model.answerText(), replyTo, maxWaitMs);
+            Integer sentId = sendAnswerChunks(chatId, answerChunks, replyTo, maxWaitMs);
             if (sentId == null) {
                 log.error("Final Telegram answer send failed for chatId={}", chatId);
                 return false;
             }
             ctx.setTentativeAnswerMessageId(sentId);
             ctx.markAnswerEdited();
-        } else if (!messageSender.editHtmlReliable(chatId, answerId, html, false, maxWaitMs)) {
-            Integer sentId = messageSender.sendHtmlReliableAndGetId(
-                    chatId, html, null, false, maxWaitMs);
+        } else if (answerChunks.size() == 1) {
+            String html = toHtmlChunk(answerChunks.getFirst());
+            if (!messageSender.editHtmlReliable(chatId, answerId, html, false, maxWaitMs)) {
+                Integer sentId = messageSender.sendHtmlReliableAndGetId(
+                        chatId, html, null, false, maxWaitMs);
+                if (sentId == null) {
+                    log.error("Final Telegram answer edit and fallback send failed for chatId={}", chatId);
+                    return false;
+                }
+                ctx.setTentativeAnswerMessageId(sentId);
+            }
+            ctx.markAnswerEdited();
+        } else {
+            String firstHtml = toHtmlChunk(answerChunks.getFirst());
+            Integer lastId = answerId;
+            if (!messageSender.editHtmlReliable(chatId, answerId, firstHtml, false, maxWaitMs)) {
+                lastId = messageSender.sendHtmlReliableAndGetId(
+                        chatId, firstHtml, null, false, maxWaitMs);
+            }
+            if (lastId == null) {
+                log.error("Final Telegram answer first chunk edit/send failed for chatId={}", chatId);
+                return false;
+            }
+            Integer sentId = sendAnswerChunks(chatId, answerChunks.subList(1, answerChunks.size()), null, maxWaitMs);
             if (sentId == null) {
-                log.error("Final Telegram answer edit and fallback send failed for chatId={}", chatId);
+                log.error("Final Telegram answer trailing chunks send failed for chatId={}", chatId);
                 return false;
             }
             ctx.setTentativeAnswerMessageId(sentId);
             ctx.markAnswerEdited();
-        } else {
-            ctx.markAnswerEdited();
         }
         ctx.setTentativeAnswerActive(false);
         ctx.setAlreadySentInStream(true);
@@ -159,48 +185,111 @@ private boolean flushAnswer(MessageHandlerContext ctx, TelegramAgentStreamModel
         return true;
     }
 
-    private Integer sendAnswerChunks(Long chatId, String answerText, Integer replyTo, long maxWaitMs) {
+    private Integer sendAnswerChunks(Long chatId, List<String> chunks, Integer replyTo, long maxWaitMs) {
+        Integer lastId = null;
+        Integer currentReplyTo = replyTo;
+        for (String chunk : chunks) {
+            lastId = sendAnswerChunk(chatId, chunk, currentReplyTo, maxWaitMs);
+            if (lastId == null) {
+                return null;
+            }
+            currentReplyTo = null;
+        }
+        return lastId;
+    }
+
+    private Integer sendAnswerChunk(Long chatId, String markdown, Integer replyTo, long maxWaitMs) {
+        String html = toHtmlChunk(markdown);
         int maxLength = telegramProperties.getMaxMessageLength();
-        if (answerText.length() <= maxLength) {
-            return messageSender.sendHtmlReliableAndGetId(
-                    chatId, AIUtils.convertMarkdownToHtml(answerText), replyTo, false, maxWaitMs);
+        if (html.length() > maxLength) {
+            log.error("Refusing to send oversized Telegram answer chunk: chatId={}, htmlLength={}, maxLength={}",
+                    chatId, html.length(), maxLength);
+            return null;
         }
-        Integer lastId = null;
-        String[] paragraphs = answerText.split("\n\n");
+        return messageSender.sendHtmlReliableAndGetId(
+                chatId, html, replyTo, false, maxWaitMs);
+    }
+
+    private List<String> splitAnswerChunks(String answerText) {
+        int maxLength = telegramProperties.getMaxMessageLength();
+        List<String> chunks = new ArrayList<>();
+        if (answerText == null || answerText.isBlank()) {
+            return chunks;
+        }
+        String[] paragraphs = answerText.split("\n\n", -1);
         StringBuilder buffer = new StringBuilder();
-        Integer currentReplyTo = replyTo;
         for (String paragraph : paragraphs) {
-            while (paragraph.length() > maxLength) {
-                if (!buffer.isEmpty()) {
-                    lastId = sendAnswerChunk(chatId, buffer.toString().trim(), currentReplyTo, maxWaitMs);
-                    if (lastId == null) {
-                        return null;
-                    }
-                    currentReplyTo = null;
-                    buffer.setLength(0);
-                }
-                String chunk = paragraph.substring(0, maxLength);
-                lastId = sendAnswerChunk(chatId, chunk, currentReplyTo, maxWaitMs);
-                if (lastId == null) {
-                    return null;
-                }
-                currentReplyTo = null;
-                paragraph = paragraph.substring(maxLength);
+            String candidate = buffer.isEmpty() ? paragraph : buffer + "\n\n" + paragraph;
+            if (fitsTelegramHtml(candidate, maxLength)) {
+                buffer.setLength(0);
+                buffer.append(candidate);
+                continue;
+            }
+            flushAnswerBuffer(buffer, chunks);
+            splitOversizedParagraph(paragraph, chunks, maxLength);
+        }
+        flushAnswerBuffer(buffer, chunks);
+        return chunks;
+    }
+
+    private void splitOversizedParagraph(String paragraph, List<String> chunks, int maxLength) {
+        String remaining = paragraph;
+        while (!remaining.isEmpty()) {
+            int splitPoint = findMarkdownSplitPointForHtmlLimit(remaining, maxLength);
+            if (splitPoint <= 0) {
+                chunks.clear();
+                return;
             }
-            if (!buffer.isEmpty()) {
-                buffer.append("\n\n");
+            String chunk = remaining.substring(0, splitPoint).trim();
+            if (!chunk.isEmpty()) {
+                chunks.add(chunk);
             }
-            buffer.append(paragraph);
+            remaining = remaining.substring(splitPoint).stripLeading();
         }
-        if (!buffer.isEmpty()) {
-            lastId = sendAnswerChunk(chatId, buffer.toString().trim(), currentReplyTo, maxWaitMs);
+    }
+
+    private int findMarkdownSplitPointForHtmlLimit(String text, int maxLength) {
+        if (fitsTelegramHtml(text, maxLength)) {
+            return text.length();
         }
-        return lastId;
+        int low = 1;
+        int high = Math.min(text.length(), maxLength);
+        int best = 0;
+        while (low <= high) {
+            int mid = (low + high) >>> 1;
+            if (fitsTelegramHtml(text.substring(0, mid), maxLength)) {
+                best = mid;
+                low = mid + 1;
+            } else {
+                high = mid - 1;
+            }
+        }
+        if (best <= 0) {
+            return 0;
+        }
+        int preferred = AIUtils.findSplitPoint(text, best);
+        return preferred > 0 && fitsTelegramHtml(text.substring(0, preferred), maxLength)
+                ? preferred
+                : best;
     }
 
-    private Integer sendAnswerChunk(Long chatId, String markdown, Integer replyTo, long maxWaitMs) {
-        return messageSender.sendHtmlReliableAndGetId(
-                chatId, AIUtils.convertMarkdownToHtml(markdown), replyTo, false, maxWaitMs);
+    private void flushAnswerBuffer(StringBuilder buffer, List<String> chunks) {
+        if (buffer.isEmpty()) {
+            return;
+        }
+        String chunk = buffer.toString().trim();
+        if (!chunk.isEmpty()) {
+            chunks.add(chunk);
+        }
+        buffer.setLength(0);
+    }
+
+    private boolean fitsTelegramHtml(String markdown, int maxLength) {
+        return toHtmlChunk(markdown).length() <= maxLength;
+    }
+
+    private String toHtmlChunk(String markdown) {
+        return AIUtils.convertMarkdownToHtml(markdown);
     }
 
     private boolean reserveForView(Long chatId, boolean force) {
diff --git a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/TelegramBotMenuService.java b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/TelegramBotMenuService.java
index f963b023..272a1da0 100644
--- a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/TelegramBotMenuService.java
+++ b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/TelegramBotMenuService.java
@@ -7,7 +7,7 @@
 import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
 import io.github.ngirchev.opendaimon.common.model.User;
 import io.github.ngirchev.opendaimon.telegram.TelegramBot;
-import io.github.ngirchev.opendaimon.telegram.command.handler.TelegramSupportedCommandProvider;
+import io.github.ngirchev.opendaimon.telegram.command.TelegramSupportedCommandProvider;
 import io.github.ngirchev.opendaimon.telegram.model.TelegramGroup;
 import io.github.ngirchev.opendaimon.telegram.model.TelegramUser;
 
diff --git a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/TelegramDeliveryFailedException.java b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/TelegramDeliveryFailedException.java
similarity index 79%
rename from opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/TelegramDeliveryFailedException.java
rename to opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/TelegramDeliveryFailedException.java
index ef1ed435..87ad71b6 100644
--- a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/TelegramDeliveryFailedException.java
+++ b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/TelegramDeliveryFailedException.java
@@ -1,4 +1,4 @@
-package io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm;
+package io.github.ngirchev.opendaimon.telegram.service;
 
 public class TelegramDeliveryFailedException extends RuntimeException {
 
diff --git a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/TelegramMessageSender.java b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/TelegramMessageSender.java
similarity index 99%
rename from opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/TelegramMessageSender.java
rename to opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/TelegramMessageSender.java
index efbd9f3b..ec9251c5 100644
--- a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/TelegramMessageSender.java
+++ b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/TelegramMessageSender.java
@@ -1,4 +1,4 @@
-package io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm;
+package io.github.ngirchev.opendaimon.telegram.service;
 
 import io.github.ngirchev.opendaimon.common.model.ConversationThread;
 import io.github.ngirchev.opendaimon.common.service.MessageLocalizationService;
diff --git a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/MessageHandlerActions.java b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/fsm/MessageHandlerActions.java
similarity index 97%
rename from opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/MessageHandlerActions.java
rename to opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/fsm/MessageHandlerActions.java
index a3072ca1..bb42368b 100644
--- a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/MessageHandlerActions.java
+++ b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/fsm/MessageHandlerActions.java
@@ -1,4 +1,4 @@
-package io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm;
+package io.github.ngirchev.opendaimon.telegram.service.fsm;
 
 /**
  * Actions invoked by the message handler FSM during state transitions.
diff --git a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/MessageHandlerContext.java b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/fsm/MessageHandlerContext.java
similarity index 99%
rename from opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/MessageHandlerContext.java
rename to opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/fsm/MessageHandlerContext.java
index 0c901a5e..159c2873 100644
--- a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/MessageHandlerContext.java
+++ b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/fsm/MessageHandlerContext.java
@@ -1,4 +1,4 @@
-package io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm;
+package io.github.ngirchev.opendaimon.telegram.service.fsm;
 
 import io.github.ngirchev.fsm.StateContext;
 import io.github.ngirchev.fsm.Transition;
diff --git a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/MessageHandlerErrorType.java b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/fsm/MessageHandlerErrorType.java
similarity index 92%
rename from opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/MessageHandlerErrorType.java
rename to opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/fsm/MessageHandlerErrorType.java
index a5bcb0b6..30877f5c 100644
--- a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/MessageHandlerErrorType.java
+++ b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/fsm/MessageHandlerErrorType.java
@@ -1,4 +1,4 @@
-package io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm;
+package io.github.ngirchev.opendaimon.telegram.service.fsm;
 
 /**
  * Error types for the message handler FSM.
diff --git a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/MessageHandlerEvent.java b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/fsm/MessageHandlerEvent.java
similarity index 80%
rename from opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/MessageHandlerEvent.java
rename to opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/fsm/MessageHandlerEvent.java
index 8f28b3c3..d312dc92 100644
--- a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/MessageHandlerEvent.java
+++ b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/fsm/MessageHandlerEvent.java
@@ -1,4 +1,4 @@
-package io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm;
+package io.github.ngirchev.opendaimon.telegram.service.fsm;
 
 /**
  * Events that drive the message handler FSM.
diff --git a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/MessageHandlerFsmFactory.java b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/fsm/MessageHandlerFsmFactory.java
similarity index 94%
rename from opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/MessageHandlerFsmFactory.java
rename to opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/fsm/MessageHandlerFsmFactory.java
index 23dd3d89..8629a80c 100644
--- a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/MessageHandlerFsmFactory.java
+++ b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/fsm/MessageHandlerFsmFactory.java
@@ -1,4 +1,4 @@
-package io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm;
+package io.github.ngirchev.opendaimon.telegram.service.fsm;
 
 import io.github.ngirchev.fsm.Action;
 import io.github.ngirchev.fsm.FsmFactory;
@@ -9,8 +9,8 @@
 import java.util.function.Consumer;
 import java.util.function.Predicate;
 
-import static io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerEvent.HANDLE;
-import static io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerState.*;
+import static io.github.ngirchev.opendaimon.telegram.service.fsm.MessageHandlerEvent.HANDLE;
+import static io.github.ngirchev.opendaimon.telegram.service.fsm.MessageHandlerState.*;
 
 /**
  * Creates the message handler FSM with all transitions defined declaratively.
diff --git a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/MessageHandlerState.java b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/fsm/MessageHandlerState.java
similarity index 96%
rename from opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/MessageHandlerState.java
rename to opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/fsm/MessageHandlerState.java
index d31390ff..07e4d70e 100644
--- a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/MessageHandlerState.java
+++ b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/fsm/MessageHandlerState.java
@@ -1,4 +1,4 @@
-package io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm;
+package io.github.ngirchev.opendaimon.telegram.service.fsm;
 
 /**
  * States for the Telegram message handler FSM.
diff --git a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/TelegramMessageHandlerActions.java b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/fsm/TelegramMessageHandlerActions.java
similarity index 99%
rename from opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/TelegramMessageHandlerActions.java
rename to opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/fsm/TelegramMessageHandlerActions.java
index 15bc8e5c..ac48a099 100644
--- a/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/TelegramMessageHandlerActions.java
+++ b/opendaimon-telegram/src/main/java/io/github/ngirchev/opendaimon/telegram/service/fsm/TelegramMessageHandlerActions.java
@@ -1,4 +1,4 @@
-package io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm;
+package io.github.ngirchev.opendaimon.telegram.service.fsm;
 
 import io.github.ngirchev.opendaimon.common.agent.AgentExecutor;
 import io.github.ngirchev.opendaimon.common.agent.AgentStrategy;
@@ -36,7 +36,9 @@
 import io.github.ngirchev.opendaimon.telegram.service.ReplyImageAttachmentService;
 import io.github.ngirchev.opendaimon.telegram.service.TelegramAgentStreamModel;
 import io.github.ngirchev.opendaimon.telegram.service.TelegramAgentStreamView;
+import io.github.ngirchev.opendaimon.telegram.service.TelegramDeliveryFailedException;
 import io.github.ngirchev.opendaimon.telegram.service.TelegramHtmlEscaper;
+import io.github.ngirchev.opendaimon.telegram.service.TelegramMessageSender;
 import io.github.ngirchev.opendaimon.telegram.service.TelegramProgressBatcher;
 import io.github.ngirchev.opendaimon.telegram.service.TelegramMessageService;
 import io.github.ngirchev.opendaimon.telegram.service.TelegramUserService;
diff --git a/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/arch/TelegramArchitectureTest.java b/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/arch/TelegramArchitectureTest.java
new file mode 100644
index 00000000..e5afc831
--- /dev/null
+++ b/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/arch/TelegramArchitectureTest.java
@@ -0,0 +1,83 @@
+package io.github.ngirchev.opendaimon.telegram.arch;
+
+import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes;
+import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.methods;
+import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses;
+
+import com.tngtech.archunit.core.importer.ImportOption;
+import com.tngtech.archunit.junit.AnalyzeClasses;
+import com.tngtech.archunit.junit.ArchTest;
+import com.tngtech.archunit.lang.ArchRule;
+import org.springframework.boot.autoconfigure.AutoConfiguration;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.stereotype.Component;
+import org.springframework.stereotype.Repository;
+import org.springframework.stereotype.Service;
+import org.springframework.validation.annotation.Validated;
+
+@AnalyzeClasses(
+        packages = "io.github.ngirchev.opendaimon.telegram",
+        importOptions = {
+                ImportOption.DoNotIncludeTests.class,
+                ImportOption.DoNotIncludeJars.class
+        }
+)
+class TelegramArchitectureTest {
+
+    @ArchTest
+    static final ArchRule telegram_uses_no_service_or_component_stereotypes =
+            noClasses()
+                    .should().beAnnotatedWith(Service.class)
+                    .orShould().beAnnotatedWith(Component.class)
+                    .because("telegram exports Spring beans through explicit configuration.");
+
+    @ArchTest
+    static final ArchRule telegram_uses_no_repository_classes =
+            noClasses()
+                    .that().areNotInterfaces()
+                    .should().beAnnotatedWith(Repository.class)
+                    .because("@Repository is only allowed on Spring Data repository interfaces.");
+
+    @ArchTest
+    static final ArchRule bean_methods_are_declared_only_in_config_packages =
+            methods()
+                    .that().areAnnotatedWith(Bean.class)
+                    .should().beDeclaredInClassesThat().resideInAPackage("..telegram.config..")
+                    .because("telegram beans must be exposed through explicit configuration classes.");
+
+    @ArchTest
+    static final ArchRule configuration_classes_are_declared_only_in_config_packages =
+            classes()
+                    .that().areAnnotatedWith(AutoConfiguration.class)
+                    .or().areAnnotatedWith(Configuration.class)
+                    .should().resideInAPackage("..telegram.config..")
+                    .because("Spring configuration belongs in config packages.");
+
+    @ArchTest
+    static final ArchRule configuration_properties_are_declared_only_in_config_packages =
+            classes()
+                    .that().areAnnotatedWith(ConfigurationProperties.class)
+                    .should().resideInAPackage("..telegram.config..")
+                    .andShould().haveSimpleNameEndingWith("Properties")
+                    .andShould().beAnnotatedWith(Validated.class)
+                    .because("telegram configuration properties must stay validated in config packages.");
+
+    @ArchTest
+    static final ArchRule repositories_are_accessed_only_from_service_config_or_repositories =
+            noClasses()
+                    .that().resideOutsideOfPackages(
+                            "..telegram.config..",
+                            "..telegram.repository..",
+                            "..telegram.service..")
+                    .should().dependOnClassesThat().resideInAPackage("..telegram.repository..")
+                    .because("repository access must stay behind services and explicit configuration.");
+
+    @ArchTest
+    static final ArchRule service_layer_does_not_depend_on_handler_implementations =
+            noClasses()
+                    .that().resideInAPackage("..telegram.service..")
+                    .should().dependOnClassesThat().resideInAPackage("..telegram.command.handler..")
+                    .because("telegram services may depend on command inputs, not handler implementation details.");
+}
diff --git a/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/StartTelegramTextCommandHandlerProviderTest.java b/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/StartTelegramTextCommandHandlerProviderTest.java
index 1cd17e60..cae1505e 100644
--- a/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/StartTelegramTextCommandHandlerProviderTest.java
+++ b/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/StartTelegramTextCommandHandlerProviderTest.java
@@ -1,4 +1,4 @@
-package io.github.ngirchev.opendaimon.telegram.command.handler;
+package io.github.ngirchev.opendaimon.telegram.command;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.junit.jupiter.api.Test;
@@ -8,7 +8,6 @@
 import org.springframework.boot.test.context.TestConfiguration;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Import;
-import org.springframework.test.context.ActiveProfiles;
 import org.springframework.test.context.TestPropertySource;
 import io.github.ngirchev.opendaimon.bulkhead.service.IUserPriorityService;
 import io.github.ngirchev.opendaimon.bulkhead.service.PriorityRequestExecutor;
@@ -55,7 +54,6 @@
 @SpringBootTest(classes = {
         TelegramCommandHandlerConfig.class
 })
-@ActiveProfiles("test")
 @Import(StartTelegramTextCommandHandlerProviderTest.TestConfig.class)
 @TestPropertySource(properties = {
         "open-daimon.telegram.enabled=true",
@@ -321,4 +319,3 @@ public UserRepository userRepository() {
         }
     }
 }
-
diff --git a/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/BackoffCommandHandlerTest.java b/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/BackoffCommandHandlerTest.java
index f63f6975..975c57ff 100644
--- a/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/BackoffCommandHandlerTest.java
+++ b/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/BackoffCommandHandlerTest.java
@@ -5,7 +5,7 @@
 import io.github.ngirchev.opendaimon.telegram.TelegramBot;
 import io.github.ngirchev.opendaimon.telegram.command.TelegramCommand;
 import io.github.ngirchev.opendaimon.telegram.command.TelegramCommandType;
-import io.github.ngirchev.opendaimon.telegram.command.handler.TelegramSupportedCommandProvider;
+import io.github.ngirchev.opendaimon.telegram.command.TelegramSupportedCommandProvider;
 import io.github.ngirchev.opendaimon.telegram.service.TypingIndicatorService;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
diff --git a/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/HistoryTelegramCommandHandlerTest.java b/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/HistoryTelegramCommandHandlerTest.java
index fbbc745f..0d181044 100644
--- a/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/HistoryTelegramCommandHandlerTest.java
+++ b/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/HistoryTelegramCommandHandlerTest.java
@@ -4,9 +4,9 @@
 import io.github.ngirchev.opendaimon.common.model.ConversationThread;
 import io.github.ngirchev.opendaimon.common.model.MessageRole;
 import io.github.ngirchev.opendaimon.common.model.ThreadScopeKind;
-import io.github.ngirchev.opendaimon.common.repository.OpenDaimonMessageRepository;
-import io.github.ngirchev.opendaimon.common.repository.ConversationThreadRepository;
+import io.github.ngirchev.opendaimon.common.service.ConversationThreadService;
 import io.github.ngirchev.opendaimon.common.service.MessageLocalizationService;
+import io.github.ngirchev.opendaimon.common.service.OpenDaimonMessageService;
 import io.github.ngirchev.opendaimon.telegram.command.handler.TelegramCommandHandlerException;
 import io.github.ngirchev.opendaimon.telegram.TelegramBot;
 import io.github.ngirchev.opendaimon.telegram.command.TelegramCommand;
@@ -51,9 +51,9 @@ class HistoryTelegramCommandHandlerTest {
     @Mock
     private TypingIndicatorService typingIndicatorService;
     @Mock
-    private ConversationThreadRepository threadRepository;
+    private ConversationThreadService threadService;
     @Mock
-    private OpenDaimonMessageRepository messageRepository;
+    private OpenDaimonMessageService messageService;
     @Mock
     private TelegramUserService userService;
 
@@ -73,7 +73,7 @@ void setUp() {
 
         handler = new HistoryTelegramCommandHandler(
                 botProvider, typingIndicatorService, messageLocalizationService,
-                threadRepository, messageRepository, userService);
+                threadService, messageService, userService);
     }
 
     @Test
@@ -127,7 +127,7 @@ void handleInner_whenNoActiveThread_returnsNoConversationMessage() {
 
         TelegramUser telegramUser = new TelegramUser();
         when(userService.getOrCreateUser(any())).thenReturn(telegramUser);
-        when(threadRepository.findMostRecentActiveThread(ThreadScopeKind.TELEGRAM_CHAT, CHAT_ID)).thenReturn(Optional.empty());
+        when(threadService.findCurrentThread(ThreadScopeKind.TELEGRAM_CHAT, CHAT_ID)).thenReturn(Optional.empty());
 
         TelegramCommand command = new TelegramCommand(100L, CHAT_ID,
                 new TelegramCommandType(TelegramCommand.HISTORY), update);
@@ -149,8 +149,8 @@ void handleInner_whenEmptyMessages_returnsEmptyHistoryMessage() {
         ConversationThread thread = new ConversationThread();
         thread.setThreadKey("thread-key-12");
         when(userService.getOrCreateUser(any())).thenReturn(telegramUser);
-        when(threadRepository.findMostRecentActiveThread(ThreadScopeKind.TELEGRAM_CHAT, CHAT_ID)).thenReturn(Optional.of(thread));
-        when(messageRepository.findByThreadOrderBySequenceNumberAsc(thread)).thenReturn(List.of());
+        when(threadService.findCurrentThread(ThreadScopeKind.TELEGRAM_CHAT, CHAT_ID)).thenReturn(Optional.of(thread));
+        when(messageService.findByThreadOrderBySequenceNumberAsc(thread)).thenReturn(List.of());
 
         TelegramCommand command = new TelegramCommand(100L, CHAT_ID,
                 new TelegramCommandType(TelegramCommand.HISTORY), update);
@@ -173,7 +173,7 @@ void handleInner_whenHasMessages_returnsFormattedHistory() {
         ConversationThread thread = new ConversationThread();
         thread.setThreadKey("thread-key-ab");
         when(userService.getOrCreateUser(any())).thenReturn(telegramUser);
-        when(threadRepository.findMostRecentActiveThread(ThreadScopeKind.TELEGRAM_CHAT, CHAT_ID)).thenReturn(Optional.of(thread));
+        when(threadService.findCurrentThread(ThreadScopeKind.TELEGRAM_CHAT, CHAT_ID)).thenReturn(Optional.of(thread));
 
         OpenDaimonMessage userMsg = new OpenDaimonMessage();
         userMsg.setRole(MessageRole.USER);
@@ -181,7 +181,7 @@ void handleInner_whenHasMessages_returnsFormattedHistory() {
         OpenDaimonMessage assistantMsg = new OpenDaimonMessage();
         assistantMsg.setRole(MessageRole.ASSISTANT);
         assistantMsg.setContent("Hi there");
-        when(messageRepository.findByThreadOrderBySequenceNumberAsc(thread))
+        when(messageService.findByThreadOrderBySequenceNumberAsc(thread))
                 .thenReturn(List.of(userMsg, assistantMsg));
 
         TelegramCommand command = new TelegramCommand(100L, CHAT_ID,
@@ -194,7 +194,7 @@ void handleInner_whenHasMessages_returnsFormattedHistory() {
         assertTrue(result.contains("Hello"));
         assertTrue(result.contains("Hi there"));
         assertTrue(result.contains("Total messages: 2"));
-        verify(messageRepository).findByThreadOrderBySequenceNumberAsc(thread);
+        verify(messageService).findByThreadOrderBySequenceNumberAsc(thread);
     }
 
     @Test
diff --git a/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/MessageTelegramCommandHandlerTest.java b/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/MessageTelegramCommandHandlerTest.java
index 46ab93e8..43aed161 100644
--- a/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/MessageTelegramCommandHandlerTest.java
+++ b/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/MessageTelegramCommandHandlerTest.java
@@ -18,12 +18,12 @@
 import io.github.ngirchev.opendaimon.common.service.AIGatewayRegistry;
 import io.github.ngirchev.opendaimon.common.service.OpenDaimonMessageService;
 import io.github.ngirchev.opendaimon.common.service.MessageLocalizationService;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerContext;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerEvent;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerFsmFactory;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerState;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.TelegramMessageHandlerActions;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.TelegramMessageSender;
+import io.github.ngirchev.opendaimon.telegram.service.fsm.MessageHandlerContext;
+import io.github.ngirchev.opendaimon.telegram.service.fsm.MessageHandlerEvent;
+import io.github.ngirchev.opendaimon.telegram.service.fsm.MessageHandlerFsmFactory;
+import io.github.ngirchev.opendaimon.telegram.service.fsm.MessageHandlerState;
+import io.github.ngirchev.opendaimon.telegram.service.fsm.TelegramMessageHandlerActions;
+import io.github.ngirchev.opendaimon.telegram.service.TelegramMessageSender;
 import io.github.ngirchev.opendaimon.telegram.service.TelegramAgentStreamView;
 import io.github.ngirchev.opendaimon.telegram.service.TelegramChatPacer;
 import org.junit.jupiter.api.BeforeEach;
diff --git a/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/NewThreadTelegramCommandHandlerTest.java b/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/NewThreadTelegramCommandHandlerTest.java
index 0c7c6b0d..63f8c735 100644
--- a/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/NewThreadTelegramCommandHandlerTest.java
+++ b/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/NewThreadTelegramCommandHandlerTest.java
@@ -1,8 +1,7 @@
 package io.github.ngirchev.opendaimon.telegram.command.handler.impl;
 
-import io.github.ngirchev.opendaimon.common.model.ConversationThread;
 import io.github.ngirchev.opendaimon.common.model.ThreadScopeKind;
-import io.github.ngirchev.opendaimon.common.repository.ConversationThreadRepository;
+import io.github.ngirchev.opendaimon.common.model.ConversationThread;
 import io.github.ngirchev.opendaimon.common.service.ConversationThreadService;
 import io.github.ngirchev.opendaimon.common.service.MessageLocalizationService;
 import io.github.ngirchev.opendaimon.telegram.command.handler.TelegramCommandHandlerException;
@@ -26,8 +25,6 @@
 import org.telegram.telegrambots.meta.api.objects.Update;
 import org.telegram.telegrambots.meta.api.objects.User;
 
-import java.util.Optional;
-
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
@@ -51,8 +48,6 @@ class NewThreadTelegramCommandHandlerTest {
     @Mock
     private ConversationThreadService threadService;
     @Mock
-    private ConversationThreadRepository threadRepository;
-    @Mock
     private TelegramUserService userService;
     @Mock
     private ObjectProvider<PersistentKeyboardService> persistentKeyboardServiceProvider;
@@ -72,7 +67,7 @@ void setUp() {
 
         handler = new NewThreadTelegramCommandHandler(
                 botProvider, typingIndicatorService, messageLocalizationService,
-                threadService, threadRepository, userService, persistentKeyboardServiceProvider);
+                threadService, userService, persistentKeyboardServiceProvider);
     }
 
     @Test
@@ -134,7 +129,7 @@ void handleInner_whenNoPreviousThread_createsNewAndReturnsMessage() {
         telegramUser.setTelegramId(100L);
         telegramUser.setLanguageCode("en");
         when(userService.getOrCreateUser(from)).thenReturn(telegramUser);
-        when(threadRepository.findMostRecentActiveThread(ThreadScopeKind.TELEGRAM_CHAT, CHAT_ID)).thenReturn(Optional.empty());
+        when(threadService.closeCurrentThread(ThreadScopeKind.TELEGRAM_CHAT, CHAT_ID)).thenReturn(false);
 
         ConversationThread newThread = new ConversationThread();
         newThread.setThreadKey("thread-key-abcdef12");
@@ -148,8 +143,8 @@ void handleInner_whenNoPreviousThread_createsNewAndReturnsMessage() {
         assertNotNull(result);
         assertTrue(result.contains("New conversation started"));
         assertTrue(result.contains("Thread ID:"));
+        verify(threadService).closeCurrentThread(ThreadScopeKind.TELEGRAM_CHAT, CHAT_ID);
         verify(threadService).createNewThread(telegramUser, ThreadScopeKind.TELEGRAM_CHAT, CHAT_ID);
-        verify(threadRepository).findMostRecentActiveThread(ThreadScopeKind.TELEGRAM_CHAT, CHAT_ID);
     }
 
     @Test
@@ -165,10 +160,7 @@ void handleInner_whenHasPreviousThread_closesAndCreatesNew() {
         telegramUser.setLanguageCode("en");
         when(userService.getOrCreateUser(from)).thenReturn(telegramUser);
 
-        ConversationThread oldThread = new ConversationThread();
-        oldThread.setId(1L);
-        oldThread.setThreadKey("old-key");
-        when(threadRepository.findMostRecentActiveThread(ThreadScopeKind.TELEGRAM_CHAT, CHAT_ID)).thenReturn(Optional.of(oldThread));
+        when(threadService.closeCurrentThread(ThreadScopeKind.TELEGRAM_CHAT, CHAT_ID)).thenReturn(true);
 
         ConversationThread newThread = new ConversationThread();
         newThread.setThreadKey("new-thread-key-12");
@@ -181,7 +173,7 @@ void handleInner_whenHasPreviousThread_closesAndCreatesNew() {
 
         assertNotNull(result);
         assertTrue(result.contains("Previous conversation history was saved"));
-        verify(threadService).closeThread(oldThread);
+        verify(threadService).closeCurrentThread(ThreadScopeKind.TELEGRAM_CHAT, CHAT_ID);
         verify(threadService).createNewThread(telegramUser, ThreadScopeKind.TELEGRAM_CHAT, CHAT_ID);
     }
 
diff --git a/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/StartTelegramCommandHandlerTest.java b/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/StartTelegramCommandHandlerTest.java
index 0eeb4a5d..7a7ebf15 100644
--- a/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/StartTelegramCommandHandlerTest.java
+++ b/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/StartTelegramCommandHandlerTest.java
@@ -5,7 +5,7 @@
 import io.github.ngirchev.opendaimon.telegram.TelegramBot;
 import io.github.ngirchev.opendaimon.telegram.command.TelegramCommand;
 import io.github.ngirchev.opendaimon.telegram.command.TelegramCommandType;
-import io.github.ngirchev.opendaimon.telegram.command.handler.TelegramSupportedCommandProvider;
+import io.github.ngirchev.opendaimon.telegram.command.TelegramSupportedCommandProvider;
 import io.github.ngirchev.opendaimon.telegram.service.TypingIndicatorService;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
diff --git a/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/ThreadsTelegramCommandHandlerTest.java b/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/ThreadsTelegramCommandHandlerTest.java
index 99497b11..6a56445e 100644
--- a/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/ThreadsTelegramCommandHandlerTest.java
+++ b/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/ThreadsTelegramCommandHandlerTest.java
@@ -18,7 +18,6 @@
 import org.telegram.telegrambots.meta.api.objects.User;
 import io.github.ngirchev.opendaimon.common.model.ConversationThread;
 import io.github.ngirchev.opendaimon.common.model.ThreadScopeKind;
-import io.github.ngirchev.opendaimon.common.repository.ConversationThreadRepository;
 import io.github.ngirchev.opendaimon.common.service.ConversationThreadService;
 import io.github.ngirchev.opendaimon.common.service.MessageLocalizationService;
 import io.github.ngirchev.opendaimon.telegram.TelegramBot;
@@ -55,8 +54,6 @@ class ThreadsTelegramCommandHandlerTest {
     @Mock
     private TypingIndicatorService typingIndicatorService;
     @Mock
-    private ConversationThreadRepository threadRepository;
-    @Mock
     private ConversationThreadService threadService;
     @Mock
     private TelegramUserService userService;
@@ -76,7 +73,7 @@ void setUp() {
         when(botProvider.getObject()).thenReturn(telegramBot);
 
         handler = new ThreadsTelegramCommandHandler(botProvider, typingIndicatorService, messageLocalizationService,
-                threadRepository, threadService, userService);
+                threadService, userService);
     }
 
     @Test
@@ -150,8 +147,7 @@ void handleInner_whenNoThreads_thenReturnsNoConversationsMessage() {
         TelegramUser user = new TelegramUser();
         user.setTelegramId(200L);
         when(userService.getOrCreateUser(any(User.class))).thenReturn(user);
-        when(threadRepository.findByScopeKindAndScopeIdOrderByLastActivityAtDesc(
-                ThreadScopeKind.TELEGRAM_CHAT, CHAT_ID)).thenReturn(List.of());
+        when(threadService.findThreads(ThreadScopeKind.TELEGRAM_CHAT, CHAT_ID)).thenReturn(List.of());
 
         TelegramCommand command = new TelegramCommand(200L, CHAT_ID, new TelegramCommandType(TelegramCommand.THREADS), update);
         command.languageCode("en");
@@ -180,8 +176,7 @@ void handleInner_whenHasThreads_thenSendsListWithMenuAndCancelRow() throws Teleg
         thread.setScopeId(CHAT_ID);
 
         when(userService.getOrCreateUser(from)).thenReturn(user);
-        when(threadRepository.findByScopeKindAndScopeIdOrderByLastActivityAtDesc(
-                ThreadScopeKind.TELEGRAM_CHAT, CHAT_ID)).thenReturn(List.of(thread));
+        when(threadService.findThreads(ThreadScopeKind.TELEGRAM_CHAT, CHAT_ID)).thenReturn(List.of(thread));
 
         TelegramCommand command = new TelegramCommand(200L, CHAT_ID, new TelegramCommandType(TelegramCommand.THREADS), update);
         command.languageCode("en");
@@ -335,8 +330,7 @@ void handle_whenPlainCommand_doesNotStartTyping() {
         TelegramUser user = new TelegramUser();
         user.setTelegramId(200L);
         when(userService.getOrCreateUser(any(User.class))).thenReturn(user);
-        when(threadRepository.findByScopeKindAndScopeIdOrderByLastActivityAtDesc(
-                ThreadScopeKind.TELEGRAM_CHAT, CHAT_ID)).thenReturn(List.of());
+        when(threadService.findThreads(ThreadScopeKind.TELEGRAM_CHAT, CHAT_ID)).thenReturn(List.of());
 
         TelegramCommand command = new TelegramCommand(200L, CHAT_ID, new TelegramCommandType(TelegramCommand.THREADS), update);
         command.languageCode("en");
diff --git a/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/service/TelegramAgentStreamModelTest.java b/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/service/TelegramAgentStreamModelTest.java
index f0888a46..019518a4 100644
--- a/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/service/TelegramAgentStreamModelTest.java
+++ b/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/service/TelegramAgentStreamModelTest.java
@@ -113,11 +113,12 @@ void shouldNotClearStatusWhenPostToolPartialWasNeverRenderedAsOverlay() {
     }
 
     @Test
-    @DisplayName("should leave completion marker when status was entirely overlay")
-    void shouldLeaveCompletionMarkerWhenStatusWasEntirelyOverlay() {
+    @DisplayName("should leave textual completion marker when status was entirely overlay")
+    void shouldLeaveTextualCompletionMarkerWhenStatusWasEntirelyOverlay() {
         // First-iteration straight-to-answer: partial chunk overwrites the initial
         // "💭 Thinking..." line, then FINAL arrives. Stripping leaves an empty status —
-        // Telegram rejects empty edits, so the model substitutes a "✅" marker.
+        // Telegram rejects empty edits, so the model substitutes a textual marker
+        // instead of a lone emoji, which Telegram renders oversized.
         TelegramAgentStreamModel model = new TelegramAgentStreamModel(false, false);
         model.apply(AgentStreamEvent.partialAnswer("Quick", 0));
 
@@ -127,7 +128,7 @@ void shouldLeaveCompletionMarkerWhenStatusWasEntirelyOverlay() {
 
         assertThat(model.statusHtml())
                 .doesNotContain("Quick")
-                .isEqualTo("✅");
+                .isEqualTo(TelegramAgentStreamModel.STATUS_DONE_LINE);
     }
 
     @Test
diff --git a/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/service/TelegramAgentStreamRendererTest.java b/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/service/TelegramAgentStreamRendererTest.java
index 77a23add..37248637 100644
--- a/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/service/TelegramAgentStreamRendererTest.java
+++ b/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/service/TelegramAgentStreamRendererTest.java
@@ -3,7 +3,7 @@
 import com.fasterxml.jackson.databind.ObjectMapper;
 import io.github.ngirchev.opendaimon.common.agent.AgentStreamEvent;
 import io.github.ngirchev.opendaimon.telegram.command.TelegramCommand;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerContext;
+import io.github.ngirchev.opendaimon.telegram.service.fsm.MessageHandlerContext;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.telegram.telegrambots.meta.api.objects.Message;
diff --git a/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/service/TelegramAgentStreamViewConcurrencyTest.java b/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/service/TelegramAgentStreamViewConcurrencyTest.java
index 30607ae9..5efea838 100644
--- a/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/service/TelegramAgentStreamViewConcurrencyTest.java
+++ b/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/service/TelegramAgentStreamViewConcurrencyTest.java
@@ -2,8 +2,8 @@
 
 import io.github.ngirchev.opendaimon.common.agent.AgentStreamEvent;
 import io.github.ngirchev.opendaimon.telegram.command.TelegramCommand;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerContext;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.TelegramMessageSender;
+import io.github.ngirchev.opendaimon.telegram.service.fsm.MessageHandlerContext;
+import io.github.ngirchev.opendaimon.telegram.service.TelegramMessageSender;
 import io.github.ngirchev.opendaimon.telegram.config.TelegramProperties;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeAll;
diff --git a/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/service/TelegramAgentStreamViewTest.java b/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/service/TelegramAgentStreamViewTest.java
index a4b99d15..c538dfc8 100644
--- a/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/service/TelegramAgentStreamViewTest.java
+++ b/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/service/TelegramAgentStreamViewTest.java
@@ -2,8 +2,8 @@
 
 import io.github.ngirchev.opendaimon.common.agent.AgentStreamEvent;
 import io.github.ngirchev.opendaimon.telegram.command.TelegramCommand;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.MessageHandlerContext;
-import io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm.TelegramMessageSender;
+import io.github.ngirchev.opendaimon.telegram.service.fsm.MessageHandlerContext;
+import io.github.ngirchev.opendaimon.telegram.service.TelegramMessageSender;
 import io.github.ngirchev.opendaimon.telegram.config.TelegramProperties;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
@@ -35,11 +35,12 @@ class TelegramAgentStreamViewTest {
     @Mock private TelegramMessageSender messageSender;
     @Mock private TelegramChatPacer telegramChatPacer;
 
+    private TelegramProperties properties;
     private TelegramAgentStreamView view;
 
     @BeforeEach
     void setUp() throws InterruptedException {
-        TelegramProperties properties = new TelegramProperties();
+        properties = new TelegramProperties();
         properties.setMaxMessageLength(4096);
         properties.getAgentStreamView().setFinalDeliveryTimeoutMs(5000);
         lenient().when(telegramChatPacer.tryReserve(anyLong())).thenReturn(true);
@@ -89,6 +90,54 @@ void shouldDeleteStaleStatusWhenFinalStatusEditFails() {
         assertThat(delivered).isTrue();
     }
 
+    @Test
+    @DisplayName("flushFinal should flush paragraph buffer before answer chunk exceeds Telegram limit")
+    void shouldFlushParagraphBufferBeforeAnswerChunkExceedsTelegramLimit() {
+        properties.setMaxMessageLength(120);
+        MessageHandlerContext ctx = newContext();
+        ctx.setStatusMessageId(STATUS_MESSAGE_ID);
+        TelegramAgentStreamModel model = new TelegramAgentStreamModel(false, false);
+        model.apply(AgentStreamEvent.finalAnswer("a".repeat(80) + "\n\n" + "b".repeat(80), 0));
+        when(messageSender.editHtmlReliable(eq(CHAT_ID), eq(STATUS_MESSAGE_ID), any(), eq(true), eq(5000L)))
+                .thenReturn(true);
+        when(messageSender.sendHtmlReliableAndGetId(eq(CHAT_ID), any(), any(), eq(false), eq(5000L)))
+                .thenReturn(31, 32);
+
+        boolean delivered = view.flushFinal(ctx, model);
+
+        ArgumentCaptor<String> answerCaptor = ArgumentCaptor.forClass(String.class);
+        verify(messageSender, org.mockito.Mockito.times(2)).sendHtmlReliableAndGetId(
+                eq(CHAT_ID), answerCaptor.capture(), any(), eq(false), eq(5000L));
+        assertThat(delivered).isTrue();
+        assertThat(answerCaptor.getAllValues())
+                .hasSize(2)
+                .allSatisfy(html -> assertThat(html.length()).isLessThanOrEqualTo(120));
+    }
+
+    @Test
+    @DisplayName("flushFinal should split by converted HTML length, not raw markdown length")
+    void shouldSplitAnswerByConvertedHtmlLength() {
+        properties.setMaxMessageLength(120);
+        MessageHandlerContext ctx = newContext();
+        ctx.setStatusMessageId(STATUS_MESSAGE_ID);
+        TelegramAgentStreamModel model = new TelegramAgentStreamModel(false, false);
+        model.apply(AgentStreamEvent.finalAnswer("&".repeat(25), 0));
+        when(messageSender.editHtmlReliable(eq(CHAT_ID), eq(STATUS_MESSAGE_ID), any(), eq(true), eq(5000L)))
+                .thenReturn(true);
+        when(messageSender.sendHtmlReliableAndGetId(eq(CHAT_ID), any(), any(), eq(false), eq(5000L)))
+                .thenReturn(31, 32);
+
+        boolean delivered = view.flushFinal(ctx, model);
+
+        ArgumentCaptor<String> answerCaptor = ArgumentCaptor.forClass(String.class);
+        verify(messageSender, org.mockito.Mockito.times(2)).sendHtmlReliableAndGetId(
+                eq(CHAT_ID), answerCaptor.capture(), any(), eq(false), eq(5000L));
+        assertThat(delivered).isTrue();
+        assertThat(answerCaptor.getAllValues())
+                .hasSize(2)
+                .allSatisfy(html -> assertThat(html.length()).isLessThanOrEqualTo(120));
+    }
+
     private static TelegramAgentStreamModel modelWithCleanedFinalAnswer() {
         TelegramAgentStreamModel model = new TelegramAgentStreamModel(false, false);
         model.apply(AgentStreamEvent.toolCall("web_search", "{\"query\":\"tickets\"}", 0));
diff --git a/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/service/TelegramBotMenuServiceTest.java b/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/service/TelegramBotMenuServiceTest.java
index 53b18e39..6464fa34 100644
--- a/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/service/TelegramBotMenuServiceTest.java
+++ b/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/service/TelegramBotMenuServiceTest.java
@@ -1,7 +1,7 @@
 package io.github.ngirchev.opendaimon.telegram.service;
 
 import io.github.ngirchev.opendaimon.telegram.TelegramBot;
-import io.github.ngirchev.opendaimon.telegram.command.handler.TelegramSupportedCommandProvider;
+import io.github.ngirchev.opendaimon.telegram.command.TelegramSupportedCommandProvider;
 import io.github.ngirchev.opendaimon.telegram.model.TelegramUser;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
diff --git a/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/MessageHandlerContextTest.java b/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/service/fsm/MessageHandlerContextTest.java
similarity index 96%
rename from opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/MessageHandlerContextTest.java
rename to opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/service/fsm/MessageHandlerContextTest.java
index c1abff0d..99d0a2f3 100644
--- a/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/MessageHandlerContextTest.java
+++ b/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/service/fsm/MessageHandlerContextTest.java
@@ -1,4 +1,4 @@
-package io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm;
+package io.github.ngirchev.opendaimon.telegram.service.fsm;
 
 import io.github.ngirchev.opendaimon.telegram.command.TelegramCommand;
 import org.junit.jupiter.api.DisplayName;
diff --git a/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/TelegramMessageHandlerActionsAgentTest.java b/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/service/fsm/TelegramMessageHandlerActionsAgentTest.java
similarity index 99%
rename from opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/TelegramMessageHandlerActionsAgentTest.java
rename to opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/service/fsm/TelegramMessageHandlerActionsAgentTest.java
index 0e05c768..fc32743c 100644
--- a/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/TelegramMessageHandlerActionsAgentTest.java
+++ b/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/service/fsm/TelegramMessageHandlerActionsAgentTest.java
@@ -1,4 +1,4 @@
-package io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm;
+package io.github.ngirchev.opendaimon.telegram.service.fsm;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 import io.github.ngirchev.opendaimon.common.agent.AgentExecutor;
@@ -21,6 +21,7 @@
 import io.github.ngirchev.opendaimon.telegram.service.TelegramAgentStreamRenderer;
 import io.github.ngirchev.opendaimon.telegram.service.TelegramAgentStreamView;
 import io.github.ngirchev.opendaimon.telegram.service.TelegramChatPacer;
+import io.github.ngirchev.opendaimon.telegram.service.TelegramMessageSender;
 import io.github.ngirchev.opendaimon.telegram.service.TelegramMessageService;
 import io.github.ngirchev.opendaimon.telegram.service.TelegramUserService;
 import io.github.ngirchev.opendaimon.telegram.service.TelegramUserSessionService;
diff --git a/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/TelegramMessageHandlerActionsStreamingTest.java b/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/service/fsm/TelegramMessageHandlerActionsStreamingTest.java
similarity index 99%
rename from opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/TelegramMessageHandlerActionsStreamingTest.java
rename to opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/service/fsm/TelegramMessageHandlerActionsStreamingTest.java
index a5be84b6..643b4027 100644
--- a/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/command/handler/impl/fsm/TelegramMessageHandlerActionsStreamingTest.java
+++ b/opendaimon-telegram/src/test/java/io/github/ngirchev/opendaimon/telegram/service/fsm/TelegramMessageHandlerActionsStreamingTest.java
@@ -1,4 +1,4 @@
-package io.github.ngirchev.opendaimon.telegram.command.handler.impl.fsm;
+package io.github.ngirchev.opendaimon.telegram.service.fsm;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 import io.github.ngirchev.opendaimon.common.agent.AgentExecutor;
@@ -17,6 +17,7 @@
 import io.github.ngirchev.opendaimon.telegram.service.TelegramAgentStreamRenderer;
 import io.github.ngirchev.opendaimon.telegram.service.TelegramAgentStreamView;
 import io.github.ngirchev.opendaimon.telegram.service.TelegramChatPacer;
+import io.github.ngirchev.opendaimon.telegram.service.TelegramMessageSender;
 import io.github.ngirchev.opendaimon.telegram.service.TelegramMessageService;
 import io.github.ngirchev.opendaimon.telegram.model.TelegramUser;
 import io.github.ngirchev.opendaimon.telegram.service.TelegramUserService;
diff --git a/opendaimon-ui/pom.xml b/opendaimon-ui/pom.xml
index db3d0440..426650cd 100644
--- a/opendaimon-ui/pom.xml
+++ b/opendaimon-ui/pom.xml
@@ -44,42 +44,75 @@
             <artifactId>opendaimon-rest</artifactId>
             <version>${project.version}</version>
         </dependency>
-        <!-- Spring Boot -->
+
+        <!-- Spring Framework leaves -->
         <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-web</artifactId>
-            <exclusions>
-                <exclusion>
-                    <groupId>org.springframework.boot</groupId>
-                    <artifactId>spring-boot-starter-logging</artifactId>
-                </exclusion>
-            </exclusions>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-context</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-web</artifactId>
+        </dependency>
+
+        <!-- Spring Boot core -->
         <dependency>
             <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-validation</artifactId>
+            <artifactId>spring-boot</artifactId>
         </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-thymeleaf</artifactId>
+            <artifactId>spring-boot-autoconfigure</artifactId>
         </dependency>
 
+        <!-- Tomcat embedded core (Cookie / Servlet APIs in PageController) -->
         <dependency>
-            <groupId>org.projectlombok</groupId>
-            <artifactId>lombok</artifactId>
-            <optional>true</optional>
+            <groupId>org.apache.tomcat.embed</groupId>
+            <artifactId>tomcat-embed-core</artifactId>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.apache.tomcat</groupId>
+                    <artifactId>tomcat-annotations-api</artifactId>
+                </exclusion>
+            </exclusions>
         </dependency>
 
-        <!-- Test -->
+        <!-- Logging -->
         <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-test</artifactId>
-            <scope>test</scope>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
         </dependency>
+
+        <!-- Lombok: compile-only annotation processor -->
         <dependency>
-            <groupId>org.mockito</groupId>
-            <artifactId>mockito-junit-jupiter</artifactId>
-            <scope>test</scope>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <scope>provided</scope>
+            <optional>true</optional>
         </dependency>
     </dependencies>
-</project> 
\ No newline at end of file
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-enforcer-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <id>enforce-dependency-graph</id>
+                        <configuration>
+                            <rules combine.children="append">
+                                <bannedDependencies>
+                                    <searchTransitive>true</searchTransitive>
+                                    <excludes>
+                                        <exclude>org.springframework.boot:spring-boot-starter*</exclude>
+                                    </excludes>
+                                </bannedDependencies>
+                            </rules>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+</project>
diff --git a/pom.xml b/pom.xml
index 584cb521..c2e33e61 100644
--- a/pom.xml
+++ b/pom.xml
@@ -20,6 +20,7 @@
     <modules>
         <module>opendaimon-spring-ai</module>
         <module>opendaimon-common</module>
+        <module>opendaimon-spring-boot-starter</module>
         <module>opendaimon-ui</module>
         <module>opendaimon-rest</module>
         <module>opendaimon-telegram</module>
@@ -33,8 +34,8 @@
 
     <licenses>
         <license>
-            <name>MIT License</name>
-            <url>https://opensource.org/licenses/MIT</url>
+            <name>Apache License, Version 2.0</name>
+            <url>https://www.apache.org/licenses/LICENSE-2.0.txt</url>
         </license>
     </licenses>
 
@@ -77,32 +78,39 @@
 
         <maven-plugin.version>3.11.0</maven-plugin.version>
 
-        <spring-boot.version>3.4.4</spring-boot.version>
-        <spring-boot-maven-plugin.version>3.4.4</spring-boot-maven-plugin.version>
-        <org.springframework.version>6.2.6</org.springframework.version>
-        <spring-thymeleaf.version>3.4.4</spring-thymeleaf.version>
+        <spring-boot.version>3.5.13</spring-boot.version>
+        <spring-boot-maven-plugin.version>3.5.13</spring-boot-maven-plugin.version>
         <springdoc.version>2.8.6</springdoc.version>
         <javax.version>1.3.2</javax.version>
 
-        <postgresql.version>42.7.3</postgresql.version>
-        <flyway.version>11.4.1</flyway.version>
-        <jakarta-xml-bind.version>4.0.1</jakarta-xml-bind.version>
+        <postgresql.version>42.7.10</postgresql.version>
+        <flyway.version>11.7.2</flyway.version>
+        <jakarta-xml-bind.version>4.0.4</jakarta-xml-bind.version>
+        <jaxb-runtime.version>4.0.5</jaxb-runtime.version>
 
-        <lombok.version>1.18.30</lombok.version>
+        <lombok.version>1.18.44</lombok.version>
         <byte-buddy.version>1.14.12</byte-buddy.version>
-        <micrometer-prometheus.version>1.13.5</micrometer-prometheus.version>
         <vavr.version>0.10.4</vavr.version>
-        <commons-lang3.version>3.14.0</commons-lang3.version>
+        <commons-lang3.version>3.18.0</commons-lang3.version>
+        <antlr4-runtime.version>4.13.1</antlr4-runtime.version>
+        <kotlin.version>2.2.0</kotlin.version>
+        <commons-codec.version>1.19.0</commons-codec.version>
+        <commons-collections4.version>4.5.0</commons-collections4.version>
+        <commons-compress.version>1.28.0</commons-compress.version>
+        <snakeyaml.version>2.5</snakeyaml.version>
+        <checker-qual.version>3.52.0</checker-qual.version>
+        <bouncycastle.version>1.81</bouncycastle.version>
 
         <telegram.version>6.9.7.0</telegram.version>
         <resilience4j.version>2.1.0</resilience4j.version>
         <caffeine.version>3.1.8</caffeine.version>
         <minio.version>8.5.7</minio.version>
 
+        <archunit.version>1.4.2</archunit.version>
         <okhttp.version>4.12.0</okhttp.version>
         <mockito.version>5.10.0</mockito.version>
-        <testcontainers.version>1.20.0</testcontainers.version>
-        <h2.version>2.2.224</h2.version>
+        <testcontainers.version>1.21.4</testcontainers.version>
+        <h2.version>2.3.232</h2.version>
 
         <spring-ai.version>1.1.2</spring-ai.version>
 
@@ -118,18 +126,21 @@
         <sonar-maven-plugin.version>5.5.0.6356</sonar-maven-plugin.version>
         <commons-io.version>2.20.0</commons-io.version>
         <fsm.version>1.1.0</fsm.version>
+        <maven-dependency-plugin.version>3.8.1</maven-dependency-plugin.version>
+        <maven-enforcer-plugin.version>3.6.2</maven-enforcer-plugin.version>
+        <jetbrains-annotations.version>24.1.0</jetbrains-annotations.version>
+        <tika-core.version>3.2.3</tika-core.version>
+        <swagger-annotations-jakarta.version>2.2.38</swagger-annotations-jakarta.version>
+        <httpclient.version>4.5.14</httpclient.version>
+        <flyway-database-postgresql.version>11.7.2</flyway-database-postgresql.version>
+        <pdfbox.version>3.0.5</pdfbox.version>
+        <jsoup.version>1.21.2</jsoup.version>
+        <logstash-logback-encoder.version>7.4</logstash-logback-encoder.version>
     </properties>
 
     <dependencyManagement>
         <dependencies>
             <!-- Spring dependencies -->
-            <dependency>
-                <groupId>org.springframework</groupId>
-                <artifactId>spring-framework-bom</artifactId>
-                <version>${org.springframework.version}</version>
-                <type>pom</type>
-                <scope>import</scope>
-            </dependency>
             <dependency>
                 <groupId>org.springframework.boot</groupId>
                 <artifactId>spring-boot-dependencies</artifactId>
@@ -158,12 +169,6 @@
                 <version>1.0.5</version>
             </dependency>
 
-            <dependency>
-                <groupId>org.springframework.boot</groupId>
-                <artifactId>spring-boot-starter-thymeleaf</artifactId>
-                <version>${spring-thymeleaf.version}</version>
-            </dependency>
-
             <!-- Swagger -->
             <dependency>
                 <groupId>org.springdoc</groupId>
@@ -197,13 +202,7 @@
             <dependency>
                 <groupId>org.glassfish.jaxb</groupId>
                 <artifactId>jaxb-runtime</artifactId>
-                <version>2.3.3</version>
-            </dependency>
-
-            <dependency>
-                <groupId>io.micrometer</groupId>
-                <artifactId>micrometer-registry-prometheus</artifactId>
-                <version>${micrometer-prometheus.version}</version>
+                <version>${jaxb-runtime.version}</version>
             </dependency>
 
             <dependency>
@@ -221,6 +220,51 @@
                 <artifactId>vavr</artifactId>
                 <version>${vavr.version}</version>
             </dependency>
+            <dependency>
+                <groupId>org.antlr</groupId>
+                <artifactId>antlr4-runtime</artifactId>
+                <version>${antlr4-runtime.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>org.jetbrains.kotlin</groupId>
+                <artifactId>kotlin-stdlib</artifactId>
+                <version>${kotlin.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>org.jetbrains.kotlin</groupId>
+                <artifactId>kotlin-reflect</artifactId>
+                <version>${kotlin.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>commons-codec</groupId>
+                <artifactId>commons-codec</artifactId>
+                <version>${commons-codec.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>org.apache.commons</groupId>
+                <artifactId>commons-collections4</artifactId>
+                <version>${commons-collections4.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>org.apache.commons</groupId>
+                <artifactId>commons-compress</artifactId>
+                <version>${commons-compress.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>org.yaml</groupId>
+                <artifactId>snakeyaml</artifactId>
+                <version>${snakeyaml.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>org.checkerframework</groupId>
+                <artifactId>checker-qual</artifactId>
+                <version>${checker-qual.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>org.bouncycastle</groupId>
+                <artifactId>bcprov-jdk18on</artifactId>
+                <version>${bouncycastle.version}</version>
+            </dependency>
 
             <!-- Test dependencies -->
             <dependency>
@@ -261,6 +305,124 @@
                 <artifactId>commons-io</artifactId>
                 <version>${commons-io.version}</version>
             </dependency>
+
+            <!-- Caffeine cache (declared in modules per "declare what you use") -->
+            <dependency>
+                <groupId>com.github.ben-manes.caffeine</groupId>
+                <artifactId>caffeine</artifactId>
+                <version>${caffeine.version}</version>
+            </dependency>
+
+            <!-- JetBrains @Nullable / @NotNull annotations (compile-only) -->
+            <dependency>
+                <groupId>org.jetbrains</groupId>
+                <artifactId>annotations</artifactId>
+                <version>${jetbrains-annotations.version}</version>
+            </dependency>
+
+            <!-- MinIO client (modules requiring storage declare it explicitly) -->
+            <dependency>
+                <groupId>io.minio</groupId>
+                <artifactId>minio</artifactId>
+                <version>${minio.version}</version>
+            </dependency>
+
+            <!-- Resilience4j (managed centrally; used by opendaimon-common) -->
+            <dependency>
+                <groupId>io.github.resilience4j</groupId>
+                <artifactId>resilience4j-spring-boot2</artifactId>
+                <version>${resilience4j.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>io.github.resilience4j</groupId>
+                <artifactId>resilience4j-bulkhead</artifactId>
+                <version>${resilience4j.version}</version>
+            </dependency>
+
+            <!-- Telegrambots (meta + main) -->
+            <dependency>
+                <groupId>org.telegram</groupId>
+                <artifactId>telegrambots</artifactId>
+                <version>${telegram.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>org.telegram</groupId>
+                <artifactId>telegrambots-meta</artifactId>
+                <version>${telegram.version}</version>
+            </dependency>
+
+            <!-- Apache Tika core (spring-ai-tika-document-reader transitively pulls it) -->
+            <dependency>
+                <groupId>org.apache.tika</groupId>
+                <artifactId>tika-core</artifactId>
+                <version>${tika-core.version}</version>
+            </dependency>
+
+            <!-- OkHttp client (mockwebserver companion; declared in tests directly) -->
+            <dependency>
+                <groupId>com.squareup.okhttp3</groupId>
+                <artifactId>okhttp</artifactId>
+                <version>${okhttp.version}</version>
+            </dependency>
+
+            <!-- Swagger annotations (transitively via springdoc; modules using @Operation declare it) -->
+            <dependency>
+                <groupId>io.swagger.core.v3</groupId>
+                <artifactId>swagger-annotations-jakarta</artifactId>
+                <version>${swagger-annotations-jakarta.version}</version>
+            </dependency>
+
+            <!-- Apache HttpClient (legacy, used by telegrambots SDK transitively) -->
+            <dependency>
+                <groupId>org.apache.httpcomponents</groupId>
+                <artifactId>httpclient</artifactId>
+                <version>${httpclient.version}</version>
+                <exclusions>
+                    <exclusion>
+                        <groupId>commons-logging</groupId>
+                        <artifactId>commons-logging</artifactId>
+                    </exclusion>
+                </exclusions>
+            </dependency>
+
+            <!-- Flyway PostgreSQL plugin (runtime dialect) -->
+            <dependency>
+                <groupId>org.flywaydb</groupId>
+                <artifactId>flyway-database-postgresql</artifactId>
+                <version>${flyway-database-postgresql.version}</version>
+            </dependency>
+
+            <!-- PDFBox (text extraction; spring-ai-pdf-document-reader runtime) -->
+            <dependency>
+                <groupId>org.apache.pdfbox</groupId>
+                <artifactId>pdfbox</artifactId>
+                <version>${pdfbox.version}</version>
+                <exclusions>
+                    <exclusion>
+                        <groupId>commons-logging</groupId>
+                        <artifactId>commons-logging</artifactId>
+                    </exclusion>
+                </exclusions>
+            </dependency>
+            <dependency>
+                <groupId>org.apache.pdfbox</groupId>
+                <artifactId>pdfbox-io</artifactId>
+                <version>${pdfbox.version}</version>
+            </dependency>
+
+            <!-- Jsoup HTML parser -->
+            <dependency>
+                <groupId>org.jsoup</groupId>
+                <artifactId>jsoup</artifactId>
+                <version>${jsoup.version}</version>
+            </dependency>
+
+            <!-- Logstash Logback encoder (used by opendaimon-app) -->
+            <dependency>
+                <groupId>net.logstash.logback</groupId>
+                <artifactId>logstash-logback-encoder</artifactId>
+                <version>${logstash-logback-encoder.version}</version>
+            </dependency>
         </dependencies>
     </dependencyManagement>
 
@@ -395,6 +557,56 @@
                         </execution>
                     </executions>
                 </plugin>
+
+                <!-- Dependency analyzer: enforces "declare what you use" per module so a
+                     downstream consumer pulling a single opendaimon-* module doesn't
+                     break when an upstream module re-scopes a transitive dep. -->
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-dependency-plugin</artifactId>
+                    <version>${maven-dependency-plugin.version}</version>
+                    <executions>
+                        <execution>
+                            <id>analyze</id>
+                            <phase>verify</phase>
+                            <goals>
+                                <goal>analyze-only</goal>
+                            </goals>
+                            <configuration>
+                                <failOnWarning>true</failOnWarning>
+                                <ignoreNonCompile>true</ignoreNonCompile>
+                                <outputXML>true</outputXML>
+                            </configuration>
+                        </execution>
+                    </executions>
+                </plugin>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-enforcer-plugin</artifactId>
+                    <version>${maven-enforcer-plugin.version}</version>
+                    <executions>
+                        <execution>
+                            <id>enforce-dependency-graph</id>
+                            <phase>verify</phase>
+                            <goals>
+                                <goal>enforce</goal>
+                            </goals>
+                            <configuration>
+                                <rules>
+                                    <dependencyConvergence/>
+                                    <requireUpperBoundDeps/>
+                                    <bannedDependencies>
+                                        <searchTransitive>true</searchTransitive>
+                                        <excludes>
+                                            <exclude>commons-logging:commons-logging</exclude>
+                                        </excludes>
+                                    </bannedDependencies>
+                                </rules>
+                                <fail>true</fail>
+                            </configuration>
+                        </execution>
+                    </executions>
+                </plugin>
             </plugins>
         </pluginManagement>
         <plugins>
@@ -406,6 +618,14 @@
                 <groupId>org.jacoco</groupId>
                 <artifactId>jacoco-maven-plugin</artifactId>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-dependency-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-enforcer-plugin</artifactId>
+            </plugin>
         </plugins>
     </build>
 
@@ -456,4 +676,4 @@
             </build>
         </profile>
     </profiles>
-</project>
\ No newline at end of file
+</project>