Add automated QA: schema validator, CI matrix, Docker build, and P1 test coverage (#353)

* Add automated QA: tool schema validator, feature-flag CI matrix, Docker build P0 items from the automated QA plan (#352): - Add validate_tool_schema() that checks OpenAI strict-mode rules (type: object, required keys in properties, nested object/array recursion) with 10 unit tests and 6 integration tests covering all core built-in tools - CI test matrix now runs with --all-features, default features, and --no-default-features --features libsql to catch dead code behind wrong cfg gates - CI clippy now runs the same 3-feature matrix with --all flags - Docker build job added to catch missing files in Dockerfile Co-Authored-By: Claude Opus 4.6 <[email protected]> * Add P1 automated QA tests and fix LeakDetector prefix shadowing bug P1 test coverage: config round-trip (settings + bootstrap), shell tool arg handling, safety adversarial tests (sanitizer, leak detector, allowlist), turn persistence (conversations, metadata, pagination, jobs), and a clippy fix for libsql-only builds. Fixed a real bug where AhoCorasick non-overlapping prefix iteration caused shorter prefixes (e.g. "sk-") to shadow longer ones (e.g. "sk-ant-api"), preventing Anthropic API key and SSH private key detection. Co-Authored-By: Claude Opus 4.6 <[email protected]> * Add P2 automated QA tests: chaos, lifecycle, collision, and recovery Cover all P2 items from the automated QA plan: - Circuit breaker chaos tests (hanging provider, rapid cycles, mixed errors) - Failover chaos tests (hanging failover, all-fail, tools path, single provider) - Value estimator boundary tests (negative cost, zero price, zero earnings) - Context length recovery test (ContextLengthExceeded -> compact -> retry) - WASM channel lifecycle tests (write/commit/read round-trip, namespace isolation) - Extension registry collision tests (same-name different-kind coexistence) - Extension filesystem collision tests (separate dirs, detect_kind priority) Co-Authored-By: Claude Opus 4.6 <[email protected]> * Add P3 concurrent stress tests for ContextManager and SessionManager Tests verify thread safety of double-checked locking, TOCTOU prevention, and RwLock-based concurrent access patterns under load. Co-Authored-By: Claude Opus 4.6 <[email protected]> * Add dispatcher loop guard and self-repair stuck job tests Dispatcher: test force_text mechanism prevents infinite tool call loops, verify iteration bound arithmetic guarantees termination for all configs. Self-repair: test stuck job detection, recovery within attempt limits, manual escalation when limit exceeded, graceful degradation without store/builder dependencies. Co-Authored-By: Claude Opus 4.6 <[email protected]> * Add E2E testing infrastructure design doc Python + Playwright framework with mock LLM server for deterministic browser-level testing of the web gateway. Covers connection/auth, chat round-trip with SSE streaming, and skills lifecycle scenarios. Co-Authored-By: Claude Opus 4.6 <[email protected]> * Add E2E testing infrastructure implementation plan 10-task plan covering: scaffolding, mock LLM server, helpers, conftest fixtures, connection/chat/skills test scenarios, CI workflow, README, and integration run. Co-Authored-By: Claude Opus 4.6 <[email protected]> * scaffold: E2E test project with pyproject.toml Co-Authored-By: Claude Opus 4.6 <[email protected]> * feat: E2E helpers with DOM selectors and port discovery Co-Authored-By: Claude Opus 4.6 <[email protected]> * feat: mock OpenAI-compat LLM server for E2E tests Co-Authored-By: Claude Opus 4.6 <[email protected]> * feat: E2E conftest with session fixtures for mock LLM and ironclaw Co-Authored-By: Claude Opus 4.6 <[email protected]> * feat: E2E scenario 1 -- connection and tab navigation tests Co-Authored-By: Claude Opus 4.6 <[email protected]> * feat: E2E scenario 2 -- chat message round-trip tests Co-Authored-By: Claude Opus 4.6 <[email protected]> * feat: E2E scenario 3 -- skills search, install, remove tests Co-Authored-By: Claude Opus 4.6 <[email protected]> * ci: add weekly E2E test workflow with Playwright Co-Authored-By: Claude Opus 4.6 <[email protected]> * docs: E2E test README with setup and usage instructions Co-Authored-By: Claude Opus 4.6 <[email protected]> * fix: E2E test integration fixes from first run - Use temp file DB instead of :memory: (libSQL :memory: doesn't persist tables across execute_batch) - Fix installed skills selector: #skills-list not #installed-skills - Add pytest-timeout to dependencies - Improve skills install/remove test with wait_for instead of fixed sleeps 8 passed, 1 skipped (skills install depends on ClawHub availability) Co-Authored-By: Claude Opus 4.6 <[email protected]> * test: add OpenAI strict-mode schema validator for all built-in tools (QA 1.1) Add src/tools/schema_validator.rs with validate_strict_schema() that checks tool parameter schemas against OpenAI function calling strict-mode rules: type object at top level, required keys in properties, enum type consistency, array items definitions, nested object recursion, and additionalProperties. 17 tests validate all 34+ built-in tool schemas across 5 test groups: - 9 simple tools (echo, time, json, http, shell, file read/write/list/patch) - 4 job tools (create, list, status, cancel) - 4 skill tools (list, search, install, remove) - 13 inline schemas for extension, routine, and complex job tools - 4 memory tool schemas Co-Authored-By: Claude Opus 4.6 <[email protected]> * test: add E2E scenarios for SSE reconnect, HTML injection, and tool approval (QA 3.3/5/6) Co-Authored-By: Claude Opus 4.6 <[email protected]> * fix: E2E test reliability for HTML injection and SSE reconnect - HTML injection: test sanitization directly via JS injection instead of depending on full LLM round-trip (avoids intermittent 404 from mock) - SSE reconnect: increase wait times for DB persistence and relax assertion to check total message count after history reload Co-Authored-By: Claude Opus 4.6 <[email protected]> * style: cargo fmt formatting Co-Authored-By: Claude Opus 4.6 <[email protected]> * test: add WASM and MCP tool schema validation tests (QA 1.1) Extends the schema validator with representative WASM tool schemas (weather, HTTP client, batch processor, status), MCP tool schemas (default, file read, SQL query, strict mode), and defect detection tests for common external schema issues (missing type, typo in required, array without items, enum type mismatch). Co-Authored-By: Claude Opus 4.6 <[email protected]> * test: add auth middleware and compaction module tests Auth middleware (8 new tests): valid/invalid bearer tokens, query param fallback, case sensitivity, empty tokens, whitespace handling. Compaction module (16 new tests): truncation strategy, summarize strategy with mock LLM, workspace fallback, format_turns helper, sequential compactions, coherence after compaction, token decrease verification. Co-Authored-By: Claude Opus 4.6 <[email protected]> * test: add config round-trip integration tests (QA 1.2) Test the full bootstrap .env lifecycle: write via the same format as save_bootstrap_env/upsert_bootstrap_var, read back via dotenvy, and assert values match. Covers LLM backend selection, embedding disable flag, onboard completion flag, session token keys, multi-key preservation across upsert, and special characters (spaces, equals, quotes, backslashes, hashes). Co-Authored-By: Claude Opus 4.6 <[email protected]> * test: add value estimator boundary tests and dispatcher loop guard (QA 4.3/4.4) Value estimator (14 new tests): zero/negative prices, large values, negative cost, exact margin boundaries, custom margin configuration. Dispatcher loop guard (2 new tests): verifies the dispatch loop terminates when all tool calls fail (regression guard for PR #252 infinite loop) and when max iterations are reached. Co-Authored-By: Claude Opus 4.6 <[email protected]> * test: add failover edge cases and provider chaos tests (QA 2.6/4.1) Failover edge cases (4 new tests): cooldown at zero nanos, half-open failure reopens circuit, all providers fail gracefully (no panic), single failing provider with cooldown. Provider chaos tests (15 new tests): flakey provider with retries, hanging provider with timeout, garbage provider, circuit breaker trip/recover, failover chain cascading, non-transient error stops chain, full stack integration (retry + failover + circuit breaker). Co-Authored-By: Claude Opus 4.6 <[email protected]> * fix: address PR review feedback on QA tests - Fix Bearer auth case-sensitivity per RFC 6750 (auth.rs) - Refactor bootstrap.rs to expose path-parameterized variants so config_round_trip tests call real code instead of reimplementations - Remove deprecated event_loop fixture, use dynamic ports, minimal env, session-scoped browser, and wire HEADED=1 in E2E conftest - Add cross-referencing doc comments between schema validators - Simplify array validation logic in tool.rs - Bump e2e.yml checkout@v4 to @v6 Co-Authored-By: Claude Opus 4.6 <[email protected]> * style: cargo fmt and fix clippy warning in signal.rs Co-Authored-By: Claude Opus 4.6 <[email protected]> * fix: improve E2E fixture error reporting and prevent stdin blocking - Add --no-onboard flag to prevent wizard from blocking in CI - Pipe /dev/null to stdin to prevent any stdin reads from hanging - Add RUST_BACKTRACE=1 for crash diagnostics - On server startup timeout, dump stderr to pytest output so CI logs show why the server failed to start Co-Authored-By: Claude Opus 4.6 <[email protected]> * fix: set session-scoped event loop for E2E async fixtures pytest-asyncio 1.3.0 defaults asyncio_default_fixture_loop_scope to None (function scope), causing session-scoped async fixtures to be re-evaluated per test function with independent event loops. Each test then independently attempts to start the ironclaw server, times out at 120s, and wastes ~24 minutes of CI before the job is cancelled. Setting asyncio_default_fixture_loop_scope = "session" ensures all session-scoped async fixtures share a single event loop, so the server starts once and is reused across all tests. Also adds -x flag to pytest in CI to stop on first failure instead of running all 19 tests when the fixture is broken. Co-Authored-By: Claude Opus 4.6 <[email protected]> * fix: set test loop scope to session to match fixture loop scope With asyncio_default_fixture_loop_scope=session but asyncio_default_test_loop_scope=function (the default), tests run on a per-function event loop while fixtures produce objects (Playwright pages, browser contexts) on the session event loop. This event loop mismatch causes the test to hang indefinitely awaiting Playwright operations that are bound to the wrong loop. Setting both scopes to "session" ensures a single event loop is shared across all fixtures and tests, eliminating the deadlock. Co-Authored-By: Claude Opus 4.6 <[email protected]> * ci: add roll-up jobs to match branch protection required checks Branch protection expects "Code Style (fmt + clippy)" and "Run Tests" status checks, but only individual job names were reported. Add roll-up jobs that aggregate results and report the expected names. Co-Authored-By: Claude Opus 4.6 <[email protected]> --------- Co-authored-by: Claude Opus 4.6 <[email protected]>
2026-08-26 23:50:17 +00:00 · 2026-02-27 09:09:45 +04:00
parent e8eb4ca0bd
commit a24fd3e8a3
44 changed files with 9292 additions and 27 deletions
@@ -342,4 +342,482 @@ mod tests {
        assert_eq!(partial.turns_removed, 0);
        assert!(!partial.summary_written);
    }
+
+    // === QA Plan - Compaction strategy tests ===
+
+    use crate::agent::context_monitor::CompactionStrategy;
+    use crate::config::SafetyConfig;
+    use crate::safety::SafetyLayer;
+    use crate::testing::StubLlm;
+
+    /// Helper: build a `ContextCompactor` with the given `StubLlm`.
+    fn make_compactor(llm: Arc<StubLlm>) -> ContextCompactor {
+        let safety = Arc::new(SafetyLayer::new(&SafetyConfig {
+            max_output_length: 100_000,
+            injection_check_enabled: false,
+        }));
+        ContextCompactor::new(llm, safety)
+    }
+
+    /// Helper: build a thread with `n` completed turns.
+    /// Turn `i` has user_input "msg-{i}" and response "resp-{i}".
+    fn make_thread(n: usize) -> Thread {
+        let mut thread = Thread::new(Uuid::new_v4());
+        for i in 0..n {
+            thread.start_turn(format!("msg-{}", i));
+            thread.complete_turn(format!("resp-{}", i));
+        }
+        thread
+    }
+
+    // ------------------------------------------------------------------
+    // 1. compact_truncate keeps last N turns
+    // ------------------------------------------------------------------
+
+    #[tokio::test]
+    async fn test_compact_truncate_keeps_last_n() {
+        let llm = Arc::new(StubLlm::new("unused"));
+        let compactor = make_compactor(llm);
+        let mut thread = make_thread(10);
+        assert_eq!(thread.turns.len(), 10);
+
+        let result = compactor
+            .compact(
+                &mut thread,
+                CompactionStrategy::Truncate { keep_recent: 3 },
+                None,
+            )
+            .await
+            .expect("compact should succeed");
+
+        // Only 3 turns remain
+        assert_eq!(thread.turns.len(), 3);
+
+        // They are the most recent ones (msg-7, msg-8, msg-9)
+        assert_eq!(thread.turns[0].user_input, "msg-7");
+        assert_eq!(thread.turns[1].user_input, "msg-8");
+        assert_eq!(thread.turns[2].user_input, "msg-9");
+
+        // Turn numbers are re-indexed to 0, 1, 2
+        assert_eq!(thread.turns[0].turn_number, 0);
+        assert_eq!(thread.turns[1].turn_number, 1);
+        assert_eq!(thread.turns[2].turn_number, 2);
+
+        // Result metadata
+        assert_eq!(result.turns_removed, 7);
+        assert!(!result.summary_written);
+        assert!(result.summary.is_none());
+
+        // Tokens should be reported (before > 0 since we had content)
+        assert!(result.tokens_before > 0);
+        assert!(result.tokens_after > 0);
+        assert!(result.tokens_before > result.tokens_after);
+    }
+
+    // ------------------------------------------------------------------
+    // 2. compact_truncate with fewer turns than limit (no-op)
+    // ------------------------------------------------------------------
+
+    #[tokio::test]
+    async fn test_compact_truncate_with_fewer_turns_than_limit() {
+        let llm = Arc::new(StubLlm::new("unused"));
+        let compactor = make_compactor(llm);
+        let mut thread = make_thread(2);
+
+        let original_inputs: Vec<String> =
+            thread.turns.iter().map(|t| t.user_input.clone()).collect();
+
+        let result = compactor
+            .compact(
+                &mut thread,
+                CompactionStrategy::Truncate { keep_recent: 5 },
+                None,
+            )
+            .await
+            .expect("compact should succeed");
+
+        // All turns preserved
+        assert_eq!(thread.turns.len(), 2);
+        assert_eq!(thread.turns[0].user_input, original_inputs[0]);
+        assert_eq!(thread.turns[1].user_input, original_inputs[1]);
+
+        // No turns removed
+        assert_eq!(result.turns_removed, 0);
+        assert!(!result.summary_written);
+        assert!(result.summary.is_none());
+    }
+
+    // ------------------------------------------------------------------
+    // 3. compact_truncate with empty turns list
+    // ------------------------------------------------------------------
+
+    #[tokio::test]
+    async fn test_compact_truncate_empty_turns() {
+        let llm = Arc::new(StubLlm::new("unused"));
+        let compactor = make_compactor(llm);
+        let mut thread = Thread::new(Uuid::new_v4());
+        assert!(thread.turns.is_empty());
+
+        let result = compactor
+            .compact(
+                &mut thread,
+                CompactionStrategy::Truncate { keep_recent: 3 },
+                None,
+            )
+            .await
+            .expect("compact should succeed on empty turns");
+
+        assert!(thread.turns.is_empty());
+        assert_eq!(result.turns_removed, 0);
+        assert_eq!(result.tokens_before, 0);
+        assert_eq!(result.tokens_after, 0);
+    }
+
+    // ------------------------------------------------------------------
+    // 4. compact_with_summary produces summary turn via StubLlm
+    // ------------------------------------------------------------------
+
+    #[tokio::test]
+    async fn test_compact_with_summary_produces_summary_turn() {
+        let canned_summary =
+            "- User greeted the agent\n- Agent responded warmly\n- Five exchanges completed";
+        let llm = Arc::new(StubLlm::new(canned_summary));
+        let compactor = make_compactor(llm.clone());
+        let mut thread = make_thread(5);
+
+        let result = compactor
+            .compact(
+                &mut thread,
+                CompactionStrategy::Summarize { keep_recent: 2 },
+                None,
+            )
+            .await
+            .expect("compact with summary should succeed");
+
+        // Should keep only 2 recent turns
+        assert_eq!(thread.turns.len(), 2);
+
+        // The kept turns should be the last two (msg-3, msg-4)
+        assert_eq!(thread.turns[0].user_input, "msg-3");
+        assert_eq!(thread.turns[1].user_input, "msg-4");
+
+        // Result should report the summary
+        assert_eq!(result.turns_removed, 3);
+        assert!(result.summary.is_some());
+        let summary = result.summary.unwrap();
+        assert!(summary.contains("User greeted the agent"));
+        assert!(summary.contains("Five exchanges completed"));
+
+        // summary_written should be false since no workspace was provided
+        assert!(!result.summary_written);
+
+        // StubLlm should have been called exactly once for the summary
+        assert_eq!(llm.calls(), 1);
+    }
+
+    // ------------------------------------------------------------------
+    // 5. compact_with_summary: LLM failure returns error (does not corrupt thread)
+    // ------------------------------------------------------------------
+
+    #[tokio::test]
+    async fn test_compact_with_summary_llm_failure() {
+        let llm = Arc::new(StubLlm::failing("broken-llm"));
+        let compactor = make_compactor(llm.clone());
+        let mut thread = make_thread(8);
+        let original_len = thread.turns.len();
+
+        let result = compactor
+            .compact(
+                &mut thread,
+                CompactionStrategy::Summarize { keep_recent: 3 },
+                None,
+            )
+            .await;
+
+        // The LLM failure should propagate as an error
+        assert!(result.is_err());
+
+        // The thread should NOT have been modified (turns not truncated
+        // on failure, since the error occurs before truncation)
+        assert_eq!(thread.turns.len(), original_len);
+    }
+
+    // ------------------------------------------------------------------
+    // 6. compact_with_summary: fewer turns than keep_recent is a no-op
+    // ------------------------------------------------------------------
+
+    #[tokio::test]
+    async fn test_compact_with_summary_fewer_turns_than_keep() {
+        let llm = Arc::new(StubLlm::new("should not be called"));
+        let compactor = make_compactor(llm.clone());
+        let mut thread = make_thread(3);
+
+        let result = compactor
+            .compact(
+                &mut thread,
+                CompactionStrategy::Summarize { keep_recent: 5 },
+                None,
+            )
+            .await
+            .expect("compact should succeed");
+
+        // No turns removed, LLM never called
+        assert_eq!(thread.turns.len(), 3);
+        assert_eq!(result.turns_removed, 0);
+        assert!(result.summary.is_none());
+        assert_eq!(llm.calls(), 0);
+    }
+
+    // ------------------------------------------------------------------
+    // 7. compact_to_workspace without workspace falls back to truncation
+    // ------------------------------------------------------------------
+
+    #[tokio::test]
+    async fn test_compact_to_workspace_without_workspace_falls_back() {
+        let llm = Arc::new(StubLlm::new("unused"));
+        let compactor = make_compactor(llm);
+        let mut thread = make_thread(20);
+
+        let result = compactor
+            .compact(&mut thread, CompactionStrategy::MoveToWorkspace, None)
+            .await
+            .expect("compact should succeed");
+
+        // Without a workspace, compact_to_workspace falls back to truncation
+        // keeping 5 turns (the hardcoded fallback in the code)
+        assert_eq!(thread.turns.len(), 5);
+        assert_eq!(result.turns_removed, 15);
+
+        // The remaining turns should be the last 5
+        assert_eq!(thread.turns[0].user_input, "msg-15");
+        assert_eq!(thread.turns[4].user_input, "msg-19");
+    }
+
+    // ------------------------------------------------------------------
+    // 8. compact_to_workspace: fewer turns than keep is a no-op
+    // ------------------------------------------------------------------
+
+    #[tokio::test]
+    async fn test_compact_to_workspace_fewer_turns_noop() {
+        let llm = Arc::new(StubLlm::new("unused"));
+        let compactor = make_compactor(llm);
+        // MoveToWorkspace keeps 10 turns when workspace is available.
+        // Without workspace it falls back to truncate(5).
+        // With fewer turns, test the no-workspace fallback path:
+        let mut thread = make_thread(4);
+
+        let result = compactor
+            .compact(&mut thread, CompactionStrategy::MoveToWorkspace, None)
+            .await
+            .expect("compact should succeed");
+
+        // 4 turns < 5 (fallback keep_recent), so no truncation
+        assert_eq!(thread.turns.len(), 4);
+        assert_eq!(result.turns_removed, 0);
+    }
+
+    // ------------------------------------------------------------------
+    // 9. format_turns_for_storage includes tool calls
+    // ------------------------------------------------------------------
+
+    #[test]
+    fn test_format_turns_for_storage_with_tool_calls() {
+        let mut thread = Thread::new(Uuid::new_v4());
+        thread.start_turn("Search for X");
+        // Record a tool call on the current turn
+        if let Some(turn) = thread.turns.last_mut() {
+            turn.record_tool_call("search", serde_json::json!({"query": "X"}));
+        }
+        thread.complete_turn("Found X");
+
+        let formatted = format_turns_for_storage(&thread.turns);
+        assert!(formatted.contains("Turn 1"));
+        assert!(formatted.contains("Search for X"));
+        assert!(formatted.contains("Found X"));
+        assert!(formatted.contains("Tools: search"));
+    }
+
+    // ------------------------------------------------------------------
+    // 10. format_turns_for_storage with no response (incomplete turn)
+    // ------------------------------------------------------------------
+
+    #[test]
+    fn test_format_turns_for_storage_incomplete_turn() {
+        let mut thread = Thread::new(Uuid::new_v4());
+        thread.start_turn("In progress message");
+        // Don't complete the turn
+
+        let formatted = format_turns_for_storage(&thread.turns);
+        assert!(formatted.contains("Turn 1"));
+        assert!(formatted.contains("In progress message"));
+        // No "Agent:" line since response is None
+        assert!(!formatted.contains("Agent:"));
+    }
+
+    // ------------------------------------------------------------------
+    // 11. format_turns_for_storage empty list
+    // ------------------------------------------------------------------
+
+    #[test]
+    fn test_format_turns_for_storage_empty() {
+        let formatted = format_turns_for_storage(&[]);
+        assert!(formatted.is_empty());
+    }
+
+    // ------------------------------------------------------------------
+    // 12. Token counts decrease after truncation
+    // ------------------------------------------------------------------
+
+    #[tokio::test]
+    async fn test_tokens_decrease_after_compaction() {
+        let llm = Arc::new(StubLlm::new("unused"));
+        let compactor = make_compactor(llm);
+        let mut thread = make_thread(20);
+
+        let result = compactor
+            .compact(
+                &mut thread,
+                CompactionStrategy::Truncate { keep_recent: 5 },
+                None,
+            )
+            .await
+            .expect("compact should succeed");
+
+        assert!(
+            result.tokens_after < result.tokens_before,
+            "tokens_after ({}) should be less than tokens_before ({})",
+            result.tokens_after,
+            result.tokens_before
+        );
+    }
+
+    // ------------------------------------------------------------------
+    // 13. compact_with_summary: keep_recent=0 removes all turns
+    // ------------------------------------------------------------------
+
+    #[tokio::test]
+    async fn test_compact_truncate_keep_zero() {
+        let llm = Arc::new(StubLlm::new("unused"));
+        let compactor = make_compactor(llm);
+        let mut thread = make_thread(5);
+
+        let result = compactor
+            .compact(
+                &mut thread,
+                CompactionStrategy::Truncate { keep_recent: 0 },
+                None,
+            )
+            .await
+            .expect("compact should succeed");
+
+        assert!(thread.turns.is_empty());
+        assert_eq!(result.turns_removed, 5);
+        assert_eq!(result.tokens_after, 0);
+    }
+
+    // ------------------------------------------------------------------
+    // 14. Summarize with keep_recent=0 summarizes all and removes all
+    // ------------------------------------------------------------------
+
+    #[tokio::test]
+    async fn test_compact_with_summary_keep_zero() {
+        let llm = Arc::new(StubLlm::new("Summary of all turns"));
+        let compactor = make_compactor(llm.clone());
+        let mut thread = make_thread(5);
+
+        let result = compactor
+            .compact(
+                &mut thread,
+                CompactionStrategy::Summarize { keep_recent: 0 },
+                None,
+            )
+            .await
+            .expect("compact should succeed");
+
+        assert!(thread.turns.is_empty());
+        assert_eq!(result.turns_removed, 5);
+        assert!(result.summary.is_some());
+        assert_eq!(result.summary.unwrap(), "Summary of all turns");
+        assert_eq!(llm.calls(), 1);
+    }
+
+    // ------------------------------------------------------------------
+    // 15. Messages are correctly built from turns for thread.messages()
+    //     after compaction
+    // ------------------------------------------------------------------
+
+    #[tokio::test]
+    async fn test_messages_coherent_after_compaction() {
+        let llm = Arc::new(StubLlm::new("unused"));
+        let compactor = make_compactor(llm);
+        let mut thread = make_thread(10);
+
+        compactor
+            .compact(
+                &mut thread,
+                CompactionStrategy::Truncate { keep_recent: 3 },
+                None,
+            )
+            .await
+            .expect("compact should succeed");
+
+        let messages = thread.messages();
+        // 3 turns * 2 messages each (user + assistant) = 6
+        assert_eq!(messages.len(), 6);
+
+        // Verify alternating user/assistant pattern
+        for (i, msg) in messages.iter().enumerate() {
+            if i % 2 == 0 {
+                assert_eq!(msg.role, crate::llm::Role::User);
+            } else {
+                assert_eq!(msg.role, crate::llm::Role::Assistant);
+            }
+        }
+
+        // Verify content matches the last 3 original turns
+        assert_eq!(messages[0].content, "msg-7");
+        assert_eq!(messages[1].content, "resp-7");
+        assert_eq!(messages[4].content, "msg-9");
+        assert_eq!(messages[5].content, "resp-9");
+    }
+
+    // ------------------------------------------------------------------
+    // 16. Multiple sequential compactions work correctly
+    // ------------------------------------------------------------------
+
+    #[tokio::test]
+    async fn test_sequential_compactions() {
+        let llm = Arc::new(StubLlm::new("unused"));
+        let compactor = make_compactor(llm);
+        let mut thread = make_thread(20);
+
+        // First compaction: 20 -> 10
+        let r1 = compactor
+            .compact(
+                &mut thread,
+                CompactionStrategy::Truncate { keep_recent: 10 },
+                None,
+            )
+            .await
+            .expect("first compact");
+        assert_eq!(thread.turns.len(), 10);
+        assert_eq!(r1.turns_removed, 10);
+
+        // Second compaction: 10 -> 3
+        let r2 = compactor
+            .compact(
+                &mut thread,
+                CompactionStrategy::Truncate { keep_recent: 3 },
+                None,
+            )
+            .await
+            .expect("second compact");
+        assert_eq!(thread.turns.len(), 3);
+        assert_eq!(r2.turns_removed, 7);
+
+        // The remaining turns should be the very last 3 from the original 20
+        assert_eq!(thread.turns[0].user_input, "msg-17");
+        assert_eq!(thread.turns[1].user_input, "msg-18");
+        assert_eq!(thread.turns[2].user_input, "msg-19");
+    }
 }
@@ -1434,4 +1434,469 @@ mod tests {
            .count();
        assert_eq!(nudge_count, 1);
    }
+
+    // === QA Plan P2 - 2.7: Context length recovery ===
+
+    #[tokio::test]
+    async fn test_context_length_recovery_via_compaction_and_retry() {
+        // Simulates the dispatcher's recovery path:
+        //   1. Provider returns ContextLengthExceeded
+        //   2. compact_messages_for_retry reduces context
+        //   3. Retry with compacted messages succeeds
+        use crate::llm::Reasoning;
+        use crate::testing::StubLlm;
+
+        let stub = Arc::new(StubLlm::failing_non_transient("ctx-bomb"));
+        let safety = Arc::new(SafetyLayer::new(&SafetyConfig {
+            max_output_length: 100_000,
+            injection_check_enabled: false,
+        }));
+
+        let reasoning = Reasoning::new(stub.clone(), safety);
+
+        // Build a fat context with lots of history.
+        let messages = vec![
+            ChatMessage::system("You are a helpful assistant."),
+            ChatMessage::user("First question"),
+            ChatMessage::assistant("First answer"),
+            ChatMessage::user("Second question"),
+            ChatMessage::assistant("Second answer"),
+            ChatMessage::user("Third question"),
+            ChatMessage::assistant("Third answer"),
+            ChatMessage::user("Current request"),
+        ];
+
+        let context = crate::llm::ReasoningContext::new().with_messages(messages.clone());
+
+        // Step 1: First call fails with ContextLengthExceeded.
+        let err = reasoning.respond_with_tools(&context).await.unwrap_err();
+        assert!(
+            matches!(err, crate::error::LlmError::ContextLengthExceeded { .. }),
+            "Expected ContextLengthExceeded, got: {:?}",
+            err
+        );
+        assert_eq!(stub.calls(), 1);
+
+        // Step 2: Compact messages (same as dispatcher lines 226).
+        let compacted = compact_messages_for_retry(&messages);
+        // Should have dropped the old history, kept system + note + last user.
+        assert!(compacted.len() < messages.len());
+        assert_eq!(compacted.last().unwrap().content, "Current request");
+
+        // Step 3: Switch provider to success and retry.
+        stub.set_failing(false);
+        let retry_context = crate::llm::ReasoningContext::new().with_messages(compacted);
+
+        let result = reasoning.respond_with_tools(&retry_context).await;
+        assert!(result.is_ok(), "Retry after compaction should succeed");
+        assert_eq!(stub.calls(), 2);
+    }
+
+    // === QA Plan P2 - 4.3: Dispatcher loop guard tests ===
+
+    /// LLM provider that always returns tool calls when tools are available,
+    /// and text when tools are empty (simulating force_text stripping tools).
+    struct AlwaysToolCallProvider;
+
+    #[async_trait]
+    impl LlmProvider for AlwaysToolCallProvider {
+        fn model_name(&self) -> &str {
+            "always-tool-call"
+        }
+
+        fn cost_per_token(&self) -> (Decimal, Decimal) {
+            (Decimal::ZERO, Decimal::ZERO)
+        }
+
+        async fn complete(
+            &self,
+            _request: CompletionRequest,
+        ) -> Result<CompletionResponse, crate::error::LlmError> {
+            Ok(CompletionResponse {
+                content: "forced text response".to_string(),
+                input_tokens: 0,
+                output_tokens: 5,
+                finish_reason: FinishReason::Stop,
+            })
+        }
+
+        async fn complete_with_tools(
+            &self,
+            request: ToolCompletionRequest,
+        ) -> Result<ToolCompletionResponse, crate::error::LlmError> {
+            if request.tools.is_empty() {
+                // No tools = force_text mode; return text.
+                return Ok(ToolCompletionResponse {
+                    content: Some("forced text response".to_string()),
+                    tool_calls: Vec::new(),
+                    input_tokens: 0,
+                    output_tokens: 5,
+                    finish_reason: FinishReason::Stop,
+                });
+            }
+            // Tools available: always call one.
+            Ok(ToolCompletionResponse {
+                content: None,
+                tool_calls: vec![ToolCall {
+                    id: format!("call_{}", uuid::Uuid::new_v4()),
+                    name: "echo".to_string(),
+                    arguments: serde_json::json!({"message": "looping"}),
+                }],
+                input_tokens: 0,
+                output_tokens: 5,
+                finish_reason: FinishReason::ToolUse,
+            })
+        }
+    }
+
+    #[tokio::test]
+    async fn force_text_prevents_infinite_tool_call_loop() {
+        // Verify that Reasoning with force_text=true returns text even when
+        // the provider would normally return tool calls.
+        use crate::llm::{Reasoning, ReasoningContext, RespondResult, ToolDefinition};
+
+        let provider = Arc::new(AlwaysToolCallProvider);
+        let safety = Arc::new(SafetyLayer::new(&SafetyConfig {
+            max_output_length: 100_000,
+            injection_check_enabled: false,
+        }));
+        let reasoning = Reasoning::new(provider, safety);
+
+        let tool_def = ToolDefinition {
+            name: "echo".to_string(),
+            description: "Echo a message".to_string(),
+            parameters: serde_json::json!({"type": "object", "properties": {"message": {"type": "string"}}}),
+        };
+
+        // Without force_text: provider returns tool calls.
+        let ctx_normal = ReasoningContext::new()
+            .with_messages(vec![ChatMessage::user("hello")])
+            .with_tools(vec![tool_def.clone()]);
+        let output = reasoning.respond_with_tools(&ctx_normal).await.unwrap();
+        assert!(
+            matches!(output.result, RespondResult::ToolCalls { .. }),
+            "Without force_text, should get tool calls"
+        );
+
+        // With force_text: provider must return text (tools stripped).
+        let mut ctx_forced = ReasoningContext::new()
+            .with_messages(vec![ChatMessage::user("hello")])
+            .with_tools(vec![tool_def]);
+        ctx_forced.force_text = true;
+        let output = reasoning.respond_with_tools(&ctx_forced).await.unwrap();
+        assert!(
+            matches!(output.result, RespondResult::Text(_)),
+            "With force_text, should get text response, got: {:?}",
+            output.result
+        );
+    }
+
+    #[test]
+    fn iteration_bounds_guarantee_termination() {
+        // Verify the arithmetic that guards against infinite loops:
+        // force_text_at = max_tool_iterations
+        // nudge_at = max_tool_iterations - 1
+        // hard_ceiling = max_tool_iterations + 1
+        for max_iter in [1_usize, 2, 5, 10, 50] {
+            let force_text_at = max_iter;
+            let nudge_at = max_iter.saturating_sub(1);
+            let hard_ceiling = max_iter + 1;
+
+            // force_text_at must be reachable (> 0)
+            assert!(
+                force_text_at > 0,
+                "force_text_at must be > 0 for max_iter={max_iter}"
+            );
+
+            // nudge comes before or at the same time as force_text
+            assert!(
+                nudge_at <= force_text_at,
+                "nudge_at ({nudge_at}) > force_text_at ({force_text_at})"
+            );
+
+            // hard ceiling is strictly after force_text
+            assert!(
+                hard_ceiling > force_text_at,
+                "hard_ceiling ({hard_ceiling}) not > force_text_at ({force_text_at})"
+            );
+
+            // Simulate iteration: every iteration from 1..=hard_ceiling
+            // At force_text_at, force_text=true (should produce text and break).
+            // At hard_ceiling, the error fires (safety net).
+            let mut hit_force_text = false;
+            let mut hit_ceiling = false;
+            for iteration in 1..=hard_ceiling {
+                if iteration >= force_text_at {
+                    hit_force_text = true;
+                }
+                if iteration > max_iter + 1 {
+                    hit_ceiling = true;
+                }
+            }
+            assert!(
+                hit_force_text,
+                "force_text never triggered for max_iter={max_iter}"
+            );
+            // The ceiling should only fire if force_text somehow didn't break
+            assert!(
+                hit_ceiling || hard_ceiling <= max_iter + 1,
+                "ceiling logic inconsistent for max_iter={max_iter}"
+            );
+        }
+    }
+
+    /// LLM provider that always returns calls to a nonexistent tool, regardless
+    /// of whether tools are available. When tools are stripped (force_text), it
+    /// returns text.
+    struct FailingToolCallProvider;
+
+    #[async_trait]
+    impl LlmProvider for FailingToolCallProvider {
+        fn model_name(&self) -> &str {
+            "failing-tool-call"
+        }
+
+        fn cost_per_token(&self) -> (Decimal, Decimal) {
+            (Decimal::ZERO, Decimal::ZERO)
+        }
+
+        async fn complete(
+            &self,
+            _request: CompletionRequest,
+        ) -> Result<CompletionResponse, crate::error::LlmError> {
+            Ok(CompletionResponse {
+                content: "forced text".to_string(),
+                input_tokens: 0,
+                output_tokens: 2,
+                finish_reason: FinishReason::Stop,
+            })
+        }
+
+        async fn complete_with_tools(
+            &self,
+            request: ToolCompletionRequest,
+        ) -> Result<ToolCompletionResponse, crate::error::LlmError> {
+            if request.tools.is_empty() {
+                return Ok(ToolCompletionResponse {
+                    content: Some("forced text".to_string()),
+                    tool_calls: Vec::new(),
+                    input_tokens: 0,
+                    output_tokens: 2,
+                    finish_reason: FinishReason::Stop,
+                });
+            }
+            // Always call a tool that does not exist in the registry.
+            Ok(ToolCompletionResponse {
+                content: None,
+                tool_calls: vec![ToolCall {
+                    id: format!("call_{}", uuid::Uuid::new_v4()),
+                    name: "nonexistent_tool".to_string(),
+                    arguments: serde_json::json!({}),
+                }],
+                input_tokens: 0,
+                output_tokens: 5,
+                finish_reason: FinishReason::ToolUse,
+            })
+        }
+    }
+
+    /// Helper to build a test Agent with a custom LLM provider and
+    /// `max_tool_iterations` override.
+    fn make_test_agent_with_llm(llm: Arc<dyn LlmProvider>, max_tool_iterations: usize) -> Agent {
+        let deps = AgentDeps {
+            store: None,
+            llm,
+            cheap_llm: None,
+            safety: Arc::new(SafetyLayer::new(&SafetyConfig {
+                max_output_length: 100_000,
+                injection_check_enabled: false,
+            })),
+            tools: Arc::new(ToolRegistry::new()),
+            workspace: None,
+            extension_manager: None,
+            skill_registry: None,
+            skill_catalog: None,
+            skills_config: SkillsConfig::default(),
+            hooks: Arc::new(HookRegistry::new()),
+            cost_guard: Arc::new(CostGuard::new(CostGuardConfig::default())),
+        };
+
+        Agent::new(
+            AgentConfig {
+                name: "test-agent".to_string(),
+                max_parallel_jobs: 1,
+                job_timeout: Duration::from_secs(60),
+                stuck_threshold: Duration::from_secs(60),
+                repair_check_interval: Duration::from_secs(30),
+                max_repair_attempts: 1,
+                use_planning: false,
+                session_idle_timeout: Duration::from_secs(300),
+                allow_local_tools: false,
+                max_cost_per_day_cents: None,
+                max_actions_per_hour: None,
+                max_tool_iterations,
+                auto_approve_tools: true,
+            },
+            deps,
+            Arc::new(ChannelManager::new()),
+            None,
+            None,
+            None,
+            Some(Arc::new(ContextManager::new(1))),
+            None,
+        )
+    }
+
+    /// Regression test for the infinite loop bug (PR #252) where `continue`
+    /// skipped the index increment. When every tool call fails (e.g., tool not
+    /// found), the dispatcher must still advance through all calls and
+    /// eventually terminate via the force_text / max_iterations guard.
+    #[tokio::test]
+    async fn test_dispatcher_terminates_with_all_tool_calls_failing() {
+        use crate::agent::session::Session;
+        use crate::channels::IncomingMessage;
+        use crate::llm::ChatMessage;
+        use tokio::sync::Mutex;
+
+        let agent = make_test_agent_with_llm(Arc::new(FailingToolCallProvider), 5);
+
+        let session = Arc::new(Mutex::new(Session::new("test-user")));
+
+        // Initialize a thread in the session so the loop can record tool calls.
+        let thread_id = {
+            let mut sess = session.lock().await;
+            sess.create_thread().id
+        };
+
+        let message = IncomingMessage::new("test", "test-user", "do something");
+        let initial_messages = vec![ChatMessage::user("do something")];
+
+        // The dispatcher must terminate within 5 seconds. If there is an
+        // infinite loop bug (e.g., index not advancing on tool failure), the
+        // timeout will fire and the test will fail.
+        let result = tokio::time::timeout(
+            Duration::from_secs(5),
+            agent.run_agentic_loop(&message, session, thread_id, initial_messages),
+        )
+        .await;
+
+        assert!(
+            result.is_ok(),
+            "Dispatcher timed out -- possible infinite loop when all tool calls fail"
+        );
+
+        // The loop should complete (either with a text response from force_text,
+        // or an error from the hard ceiling). Both are acceptable termination.
+        let inner = result.unwrap();
+        assert!(
+            inner.is_ok(),
+            "Dispatcher returned an error: {:?}",
+            inner.err()
+        );
+    }
+
+    /// Verify that the max_iterations guard terminates the loop even when the
+    /// LLM always returns tool calls and those calls succeed.
+    #[tokio::test]
+    async fn test_dispatcher_terminates_with_max_iterations() {
+        use crate::agent::session::Session;
+        use crate::channels::IncomingMessage;
+        use crate::llm::ChatMessage;
+        use crate::tools::builtin::EchoTool;
+        use tokio::sync::Mutex;
+
+        // Use AlwaysToolCallProvider which calls "echo" on every turn.
+        // Register the echo tool so the calls succeed.
+        let llm: Arc<dyn LlmProvider> = Arc::new(AlwaysToolCallProvider);
+        let max_iter = 3;
+        let agent = {
+            let deps = AgentDeps {
+                store: None,
+                llm,
+                cheap_llm: None,
+                safety: Arc::new(SafetyLayer::new(&SafetyConfig {
+                    max_output_length: 100_000,
+                    injection_check_enabled: false,
+                })),
+                tools: {
+                    let registry = Arc::new(ToolRegistry::new());
+                    registry.register_sync(Arc::new(EchoTool));
+                    registry
+                },
+                workspace: None,
+                extension_manager: None,
+                skill_registry: None,
+                skill_catalog: None,
+                skills_config: SkillsConfig::default(),
+                hooks: Arc::new(HookRegistry::new()),
+                cost_guard: Arc::new(CostGuard::new(CostGuardConfig::default())),
+            };
+
+            Agent::new(
+                AgentConfig {
+                    name: "test-agent".to_string(),
+                    max_parallel_jobs: 1,
+                    job_timeout: Duration::from_secs(60),
+                    stuck_threshold: Duration::from_secs(60),
+                    repair_check_interval: Duration::from_secs(30),
+                    max_repair_attempts: 1,
+                    use_planning: false,
+                    session_idle_timeout: Duration::from_secs(300),
+                    allow_local_tools: false,
+                    max_cost_per_day_cents: None,
+                    max_actions_per_hour: None,
+                    max_tool_iterations: max_iter,
+                    auto_approve_tools: true,
+                },
+                deps,
+                Arc::new(ChannelManager::new()),
+                None,
+                None,
+                None,
+                Some(Arc::new(ContextManager::new(1))),
+                None,
+            )
+        };
+
+        let session = Arc::new(Mutex::new(Session::new("test-user")));
+        let thread_id = {
+            let mut sess = session.lock().await;
+            sess.create_thread().id
+        };
+
+        let message = IncomingMessage::new("test", "test-user", "keep calling tools");
+        let initial_messages = vec![ChatMessage::user("keep calling tools")];
+
+        // Even with an LLM that always wants to call tools, the dispatcher
+        // must terminate within the timeout thanks to force_text at
+        // max_tool_iterations.
+        let result = tokio::time::timeout(
+            Duration::from_secs(5),
+            agent.run_agentic_loop(&message, session, thread_id, initial_messages),
+        )
+        .await;
+
+        assert!(
+            result.is_ok(),
+            "Dispatcher timed out -- max_iterations guard failed to terminate the loop"
+        );
+
+        // Should get a successful text response (force_text kicks in).
+        let inner = result.unwrap();
+        assert!(
+            inner.is_ok(),
+            "Dispatcher returned an error: {:?}",
+            inner.err()
+        );
+
+        // Verify we got a text response.
+        match inner.unwrap() {
+            super::AgenticLoopResult::Response(text) => {
+                assert!(!text.is_empty(), "Expected non-empty forced text response");
+            }
+            super::AgenticLoopResult::NeedApproval { .. } => {
+                panic!("Expected text response, got NeedApproval");
+            }
+        }
+    }
 }
@@ -387,4 +387,134 @@ mod tests {
        };
        assert!(matches!(manual, RepairResult::ManualRequired { .. }));
    }
+
+    // === QA Plan - Self-repair stuck job tests ===
+
+    #[tokio::test]
+    async fn detect_no_stuck_jobs_when_all_healthy() {
+        let cm = Arc::new(ContextManager::new(10));
+
+        // Create a job and leave it Pending (not stuck).
+        cm.create_job("Job 1", "desc").await.unwrap();
+
+        let repair = DefaultSelfRepair::new(cm, Duration::from_secs(60), 3);
+        let stuck = repair.detect_stuck_jobs().await;
+        assert!(stuck.is_empty());
+    }
+
+    #[tokio::test]
+    async fn detect_stuck_job_finds_stuck_state() {
+        let cm = Arc::new(ContextManager::new(10));
+        let job_id = cm.create_job("Stuck job", "desc").await.unwrap();
+
+        // Transition to InProgress, then to Stuck.
+        cm.update_context(job_id, |ctx| ctx.transition_to(JobState::InProgress, None))
+            .await
+            .unwrap()
+            .unwrap();
+        cm.update_context(job_id, |ctx| {
+            ctx.transition_to(JobState::Stuck, Some("timed out".to_string()))
+        })
+        .await
+        .unwrap()
+        .unwrap();
+
+        let repair = DefaultSelfRepair::new(cm, Duration::from_secs(60), 3);
+        let stuck = repair.detect_stuck_jobs().await;
+        assert_eq!(stuck.len(), 1);
+        assert_eq!(stuck[0].job_id, job_id);
+    }
+
+    #[tokio::test]
+    async fn repair_stuck_job_succeeds_within_limit() {
+        let cm = Arc::new(ContextManager::new(10));
+        let job_id = cm.create_job("Repairable", "desc").await.unwrap();
+
+        // Move to InProgress -> Stuck.
+        cm.update_context(job_id, |ctx| ctx.transition_to(JobState::InProgress, None))
+            .await
+            .unwrap()
+            .unwrap();
+        cm.update_context(job_id, |ctx| ctx.transition_to(JobState::Stuck, None))
+            .await
+            .unwrap()
+            .unwrap();
+
+        let repair = DefaultSelfRepair::new(Arc::clone(&cm), Duration::from_secs(60), 3);
+
+        let stuck_job = StuckJob {
+            job_id,
+            last_activity: Utc::now(),
+            stuck_duration: Duration::from_secs(120),
+            last_error: None,
+            repair_attempts: 0,
+        };
+
+        let result = repair.repair_stuck_job(&stuck_job).await.unwrap();
+        assert!(
+            matches!(result, RepairResult::Success { .. }),
+            "Expected Success, got: {:?}",
+            result
+        );
+
+        // Job should be back to InProgress after recovery.
+        let ctx = cm.get_context(job_id).await.unwrap();
+        assert_eq!(ctx.state, JobState::InProgress);
+    }
+
+    #[tokio::test]
+    async fn repair_stuck_job_returns_manual_when_limit_exceeded() {
+        let cm = Arc::new(ContextManager::new(10));
+        let job_id = cm.create_job("Unrepairable", "desc").await.unwrap();
+
+        let repair = DefaultSelfRepair::new(cm, Duration::from_secs(60), 2);
+
+        let stuck_job = StuckJob {
+            job_id,
+            last_activity: Utc::now(),
+            stuck_duration: Duration::from_secs(300),
+            last_error: Some("persistent failure".to_string()),
+            repair_attempts: 2, // == max
+        };
+
+        let result = repair.repair_stuck_job(&stuck_job).await.unwrap();
+        assert!(
+            matches!(result, RepairResult::ManualRequired { .. }),
+            "Expected ManualRequired, got: {:?}",
+            result
+        );
+    }
+
+    #[tokio::test]
+    async fn detect_broken_tools_returns_empty_without_store() {
+        let cm = Arc::new(ContextManager::new(10));
+        let repair = DefaultSelfRepair::new(cm, Duration::from_secs(60), 3);
+
+        // No store configured, should return empty.
+        let broken = repair.detect_broken_tools().await;
+        assert!(broken.is_empty());
+    }
+
+    #[tokio::test]
+    async fn repair_broken_tool_returns_manual_without_builder() {
+        let cm = Arc::new(ContextManager::new(10));
+        let repair = DefaultSelfRepair::new(cm, Duration::from_secs(60), 3);
+
+        let broken = BrokenTool {
+            name: "test-tool".to_string(),
+            failure_count: 10,
+            last_error: Some("crash".to_string()),
+            first_failure: Utc::now(),
+            last_failure: Utc::now(),
+            last_build_result: None,
+            repair_attempts: 0,
+        };
+
+        let result = repair.repair_broken_tool(&broken).await.unwrap();
+        assert!(
+            matches!(result, RepairResult::ManualRequired { .. }),
+            "Expected ManualRequired without builder, got: {:?}",
+            result
+        );
+    }
 }
@@ -772,6 +772,116 @@ mod tests {
        assert_ne!(resolved, tid);
    }

+    // === QA Plan P3 - 4.2: Concurrent session stress tests ===
+
+    #[tokio::test]
+    async fn concurrent_get_or_create_same_user_returns_same_session() {
+        let manager = Arc::new(SessionManager::new());
+
+        let handles: Vec<_> = (0..30)
+            .map(|_| {
+                let mgr = Arc::clone(&manager);
+                tokio::spawn(async move { mgr.get_or_create_session("shared-user").await })
+            })
+            .collect();
+
+        let mut sessions = Vec::new();
+        for handle in handles {
+            sessions.push(handle.await.expect("task should not panic"));
+        }
+
+        // All 30 must return the *same* Arc (double-checked locking guarantee).
+        for s in &sessions {
+            assert!(Arc::ptr_eq(&sessions[0], s));
+        }
+    }
+
+    #[tokio::test]
+    async fn concurrent_resolve_thread_distinct_users_no_cross_talk() {
+        let manager = Arc::new(SessionManager::new());
+
+        let handles: Vec<_> = (0..20)
+            .map(|i| {
+                let mgr = Arc::clone(&manager);
+                tokio::spawn(async move {
+                    let user = format!("user-{i}");
+                    let (session, tid) = mgr.resolve_thread(&user, "gateway", None).await;
+                    (user, session, tid)
+                })
+            })
+            .collect();
+
+        let mut results = Vec::new();
+        for handle in handles {
+            results.push(handle.await.expect("task should not panic"));
+        }
+
+        // All thread IDs must be unique.
+        let tids: std::collections::HashSet<_> = results.iter().map(|(_, _, t)| *t).collect();
+        assert_eq!(tids.len(), 20);
+
+        // Each session should contain exactly 1 thread (its own).
+        for (_, session, tid) in &results {
+            let sess = session.lock().await;
+            assert!(sess.threads.contains_key(tid));
+            assert_eq!(sess.threads.len(), 1);
+        }
+    }
+
+    #[tokio::test]
+    async fn concurrent_resolve_thread_same_user_different_channels() {
+        let manager = Arc::new(SessionManager::new());
+        let channels = ["gateway", "telegram", "slack", "cli", "repl"];
+
+        let handles: Vec<_> = channels
+            .iter()
+            .map(|ch| {
+                let mgr = Arc::clone(&manager);
+                let channel = ch.to_string();
+                tokio::spawn(async move {
+                    let (session, tid) = mgr.resolve_thread("multi-ch", &channel, None).await;
+                    (channel, session, tid)
+                })
+            })
+            .collect();
+
+        let mut results = Vec::new();
+        for handle in handles {
+            results.push(handle.await.expect("task should not panic"));
+        }
+
+        // All 5 threads must be unique (different channels = different keys).
+        let tids: std::collections::HashSet<_> = results.iter().map(|(_, _, t)| *t).collect();
+        assert_eq!(tids.len(), 5);
+
+        // All threads should live in the same session.
+        let sess = results[0].1.lock().await;
+        assert_eq!(sess.threads.len(), 5);
+    }
+
+    #[tokio::test]
+    async fn concurrent_get_undo_manager_same_thread_returns_same_arc() {
+        let manager = Arc::new(SessionManager::new());
+        let (_, tid) = manager.resolve_thread("undo-user", "gateway", None).await;
+
+        let handles: Vec<_> = (0..20)
+            .map(|_| {
+                let mgr = Arc::clone(&manager);
+                tokio::spawn(async move { mgr.get_undo_manager(tid).await })
+            })
+            .collect();
+
+        let mut managers = Vec::new();
+        for handle in handles {
+            managers.push(handle.await.expect("task should not panic"));
+        }
+
+        // All 20 must point to the same UndoManager.
+        for m in &managers {
+            assert!(Arc::ptr_eq(&managers[0], m));
+        }
+    }
+
    #[tokio::test]
    async fn test_resolve_thread_finds_existing_session_thread_by_uuid() {
        use crate::agent::session::{Session, Thread};