fix: overhaul tinyclaw context compression and fix 8 bugs

Critical fixes:
- compress() now uses proxy-first fallback (proxy -> Ollama -> extractive)
  instead of always bypassing proxy and going to Ollama directly
- Summary is now injected into LLM context after compression via
  build_proxy_messages() helper with user+assistant pair
- proxy_messages built from post-compression session state, not stale
  pre-compression snapshot that caused context loss

Additional fixes:
- tools_available() no longer auto-resets failure flag (was defeating
  the circuit breaker set by tool_call() on error)
- Removed dead summarize_at_token_ratio config field
- AnthropicUsage uses Anthropic-canonical field names with OpenAI aliases
- Removed all #[allow(dead_code)] violations
- Made test_text_only_fallback deterministic (unreachable port, not default)

7 new tests covering all changes.

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

Author: Alex

.beads/issues.jsonl

@@ -1,4 +1,11 @@
+{"id":"terraphim-ai-061","title":"Fix tools_available() auto-reset side effect","status":"closed","priority":2,"issue_type":"bug","owner":"alex@example.com","created_at":"2026-02-26T16:28:08.006176745Z","created_by":"Alex","updated_at":"2026-02-26T19:07:04.472260702Z","closed_at":"2026-02-26T19:07:04.472260702Z","close_reason":"Closed"}
 {"id":"terraphim-ai-2sz","title":"Add embedded device settings fallback to terraphim-cli","description":"Evaluate and implement an embedded DeviceSettings fallback (similar to terraphim-agent) so terraphim-cli doesn't fail on missing settings.","status":"open","priority":2,"issue_type":"task","owner":"alex@metacortex.engineer","created_at":"2026-02-10T08:23:48.689656434Z","created_by":"AlexMikhalev","updated_at":"2026-02-10T08:23:48.689656434Z"}
+{"id":"terraphim-ai-8ld","title":"Rewrite compress() with proxy-first fallback","status":"closed","priority":1,"issue_type":"bug","owner":"alex@example.com","created_at":"2026-02-26T16:28:28.794633105Z","created_by":"Alex","updated_at":"2026-02-26T19:07:04.510972897Z","closed_at":"2026-02-26T19:07:04.510972897Z","close_reason":"Closed"}
 {"id":"terraphim-ai-cbm","title":"Clarify terraphim-agent TUI offline/server requirement","description":"Determine whether terraphim-agent TUI is expected to work fully offline or requires a running server; document requirement and adjust behavior if needed.","design":"Phase 1/2 docs: docs/plans/terraphim-agent-tui-offline-server-research-2026-02-13.md and docs/plans/terraphim-agent-tui-offline-server-design-2026-02-13.md","acceptance_criteria":"Contract for fullscreen TUI vs REPL/offline is explicit in help/docs; actionable messaging when fullscreen TUI server is unreachable; tests cover mode behavior to prevent regressions.","notes":"Implemented on 2026-02-13: mode-contract wording in CLI/docs, fullscreen TUI server preflight with actionable repl fallback, and regression tests for help/non-TTY/server-failure paths. Validation: cargo fmt --package terraphim_agent; cargo clippy -p terraphim_agent --all-targets -- -D warnings; cargo test -p terraphim_agent --test offline_mode_tests; cargo test -p terraphim_agent --test server_mode_tests test_server_mode_config_show; targeted unit tests in main.rs for URL resolution and error messaging.","status":"closed","priority":2,"issue_type":"task","owner":"alex@metacortex.engineer","created_at":"2026-02-10T08:23:40.310825316Z","created_by":"AlexMikhalev","updated_at":"2026-02-23T10:46:13.066528719Z","closed_at":"2026-02-13T14:41:42.09313609Z"}
 {"id":"terraphim-ai-iwy","title":"Add knowledge graph ranking example and guide","status":"closed","priority":2,"issue_type":"feature","owner":"alex@example.com","created_at":"2026-02-15T11:54:58.063432151Z","created_by":"Alex","updated_at":"2026-02-15T11:58:22.282021161Z","closed_at":"2026-02-15T11:58:22.282021161Z","close_reason":"Created knowledge graph ranking example and guide article"}
+{"id":"terraphim-ai-ou6","title":"Make test_text_only_fallback deterministic","status":"closed","priority":2,"issue_type":"bug","owner":"alex@example.com","created_at":"2026-02-26T16:28:23.598516653Z","created_by":"Alex","updated_at":"2026-02-26T19:07:04.509756346Z","closed_at":"2026-02-26T19:07:04.509756346Z","close_reason":"Closed"}
+{"id":"terraphim-ai-pdl","title":"Remove all #[allow(dead_code)] annotations","status":"closed","priority":3,"issue_type":"task","owner":"alex@example.com","created_at":"2026-02-26T16:28:39.215892144Z","created_by":"Alex","updated_at":"2026-02-26T19:07:04.513163031Z","closed_at":"2026-02-26T19:07:04.513163031Z","close_reason":"Closed"}
+{"id":"terraphim-ai-q63","title":"Remove dead summarize_at_token_ratio config","status":"closed","priority":3,"issue_type":"bug","owner":"alex@example.com","created_at":"2026-02-26T16:28:13.176563141Z","created_by":"Alex","updated_at":"2026-02-26T19:07:04.506195356Z","closed_at":"2026-02-26T19:07:04.506195356Z","close_reason":"Closed"}
+{"id":"terraphim-ai-rv5","title":"Fix AnthropicUsage field naming to Anthropic convention","status":"closed","priority":3,"issue_type":"bug","owner":"alex@example.com","created_at":"2026-02-26T16:28:18.370689359Z","created_by":"Alex","updated_at":"2026-02-26T19:07:04.50862237Z","closed_at":"2026-02-26T19:07:04.50862237Z","close_reason":"Closed"}
 {"id":"terraphim-ai-tcw","title":"Define required feature parity between terraphim-agent and terraphim-cli","description":"Decide which commands/features must exist in both CLIs and document any intentional gaps for automation vs interactive use.","status":"open","priority":3,"issue_type":"task","owner":"alex@metacortex.engineer","created_at":"2026-02-10T08:23:51.548645229Z","created_by":"AlexMikhalev","updated_at":"2026-02-10T08:23:51.548645229Z"}
+{"id":"terraphim-ai-yuk","title":"Fix stale data + inject summary into LLM context","status":"closed","priority":0,"issue_type":"bug","owner":"alex@example.com","created_at":"2026-02-26T16:28:34.015795558Z","created_by":"Alex","updated_at":"2026-02-26T19:07:04.512036157Z","closed_at":"2026-02-26T19:07:04.512036157Z","close_reason":"Closed"}

crates/terraphim_tinyclaw/src/agent/agent_loop.rs

@@ -16,12 +16,9 @@ use tokio_util::sync::CancellationToken;
 
 /// Configuration for the tool-calling loop.
 #[derive(Debug, Clone)]
-#[allow(dead_code)]
 pub struct ToolCallingConfig {
     /// Maximum tool-calling iterations per message.
     pub max_iterations: usize,
-    /// Token ratio at which to trigger compression.
-    pub summarize_at_token_ratio: f32,
     /// Number of messages to keep after summarization.
     pub keep_last_messages: usize,
 }
@@ -30,7 +27,6 @@ impl Default for ToolCallingConfig {
     fn default() -> Self {
         Self {
             max_iterations: 20,
-            summarize_at_token_ratio: 0.75,
             keep_last_messages: 4,
         }
     }
@@ -160,46 +156,78 @@ impl HybridLlmRouter {
         }
     }
 
-    /// Compress context via direct LLM (cheap/local).
-    /// Never goes through proxy - uses Ollama or configured direct LLM.
+    /// Compress context via LLM summarization.
+    /// Tries proxy first (Claude/OpenAI), falls back to direct LLM (Ollama),
+    /// then to extractive summary.
     pub async fn compress(
         &self,
         messages: Vec<ChatMessage>,
         _system: String,
     ) -> anyhow::Result<String> {
-        let base_url = self
-            .direct_config
-            .base_url
-            .clone()
-            .unwrap_or_else(|| "http://127.0.0.1:11434".to_string());
-        let model = &self.direct_config.model;
-
         // Format conversation for summarization
         let conversation = messages
             .iter()
             .map(|m| format!("{:?}: {}", m.role, m.content))
             .collect::<Vec<_>>()
             .join("\n");
 
-        let prompt = format!(
+        let summarization_prompt = format!(
             "Summarize the following conversation concisely, \
              preserving key facts, decisions, and context:\n\n{}",
             conversation
         );
 
+        let summarization_system = "You are a conversation summarizer. \
+             Summarize concisely, preserving key facts, decisions, and context."
+            .to_string();
+
+        log::info!("Context compression - {} messages", messages.len());
+
+        // Tier 1: Try proxy (Claude/OpenAI via terraphim-llm-proxy)
+        if self.proxy.is_available() {
+            let proxy_messages = vec![Message::user(&summarization_prompt)];
+            match self
+                .proxy
+                .chat(proxy_messages, Some(summarization_system.clone()))
+                .await
+            {
+                Ok(response) => {
+                    log::info!(
+                        "Context compressed via proxy (model: {}, tokens: {}/{})",
+                        response.model,
+                        response.usage.input_tokens,
+                        response.usage.output_tokens
+                    );
+                    if let Some(content) = response.content {
+                        return Ok(content);
+                    }
+                }
+                Err(e) => {
+                    log::warn!("Proxy unavailable for compression: {}", e);
+                }
+            }
+        }
+
+        // Tier 2: Try direct LLM (Ollama)
+        let base_url = self
+            .direct_config
+            .base_url
+            .clone()
+            .unwrap_or_else(|| "http://127.0.0.1:11434".to_string());
+        let model = &self.direct_config.model;
+
         log::info!(
-            "Context compression via {} ({}) - {} messages",
+            "Compression fallback to {} ({})",
             self.direct_config.provider,
             model,
-            messages.len()
         );
 
         let client = reqwest::Client::new();
         let response = client
             .post(format!("{}/api/generate", base_url))
             .json(&serde_json::json!({
                 "model": model,
-                "prompt": prompt,
+                "prompt": summarization_prompt,
                 "stream": false
             }))
             .send()
@@ -245,6 +273,36 @@ impl HybridLlmRouter {
     }
 }
 
+/// Build proxy messages from session messages, optionally prepending a summary.
+///
+/// If a summary exists, it is injected as a user+assistant pair at the start
+/// to maintain the alternating message pattern required by the Anthropic API.
+fn build_proxy_messages(messages: &[ChatMessage], summary: Option<&str>) -> Vec<Message> {
+    let mut proxy_messages: Vec<Message> = Vec::new();
+
+    // Inject summary as context if it exists
+    if let Some(summary) = summary {
+        proxy_messages.push(Message::user(format!(
+            "[Previous conversation summary]: {}",
+            summary
+        )));
+        proxy_messages.push(Message::assistant(
+            "Understood, I have the context from our previous conversation.",
+        ));
+    }
+
+    // Add current messages
+    for m in messages {
+        proxy_messages.push(match m.role {
+            MessageRole::User => Message::user(&m.content),
+            MessageRole::Assistant => Message::assistant(&m.content),
+            _ => Message::user(&m.content),
+        });
+    }
+
+    proxy_messages
+}
+
 /// The main tool-calling agent loop.
 pub struct ToolCallingLoop {
     config: ToolCallingConfig,
@@ -335,23 +393,27 @@ impl ToolCallingLoop {
         };
         session.add_message(user_msg.clone());
 
-        // Store messages for LLM conversion
-        let session_messages: Vec<_> = session.messages.clone();
-        let session_clone = session.clone();
-
         // Save session before releasing lock
+        let session_clone = session.clone();
+        let message_count = session.messages.len();
         sessions_guard.save(&session_clone)?;
         drop(sessions_guard);
 
         // Check if we need compression using configured ratio
-        let needs_compress = session_messages.len() > self.config.keep_last_messages * 2;
+        let needs_compress = message_count > self.config.keep_last_messages * 2;
         if needs_compress {
             // Keep the last N messages, compress the rest
             let keep_count = self.config.keep_last_messages;
-            let messages_to_compress: Vec<_> = if session_messages.len() > keep_count {
-                session_messages[..session_messages.len() - keep_count].to_vec()
-            } else {
-                session_messages.clone()
+
+            // Re-acquire lock to read messages for compression
+            let messages_to_compress = {
+                let mut sessions_guard = self.sessions.lock().await;
+                let session = sessions_guard.get_or_create(&session_key);
+                if session.messages.len() > keep_count {
+                    session.messages[..session.messages.len() - keep_count].to_vec()
+                } else {
+                    session.messages.clone()
+                }
             };
 
             let summary = self
@@ -380,15 +442,12 @@ impl ToolCallingLoop {
             drop(sessions_guard);
         }
 
-        // Convert to proxy message format
-        let proxy_messages: Vec<Message> = session_messages
-            .iter()
-            .map(|m| match m.role {
-                MessageRole::User => Message::user(&m.content),
-                MessageRole::Assistant => Message::assistant(&m.content),
-                _ => Message::user(&m.content),
-            })
-            .collect();
+        // Build proxy messages from CURRENT session state (post-compression)
+        let proxy_messages = {
+            let mut sessions_guard = self.sessions.lock().await;
+            let session = sessions_guard.get_or_create(&session_key);
+            build_proxy_messages(&session.messages, session.summary.as_deref())
+        };
 
         // Get tool definitions
         let tool_definitions: Vec<ToolDefinition> = self
@@ -469,6 +528,14 @@ impl ToolCallingLoop {
                 }
             };
 
+            log::debug!(
+                "LLM response (model: {}, reason: {}, tokens: {}/{})",
+                response.model,
+                response.stop_reason,
+                response.usage.input_tokens,
+                response.usage.output_tokens
+            );
+
             // Check if there are tool calls
             if response.tool_calls.is_empty() {
                 // No tool calls - return the content
@@ -554,12 +621,6 @@ impl ToolCallingLoop {
             None
         }
     }
-
-    /// Trigger graceful shutdown.
-    #[allow(dead_code)]
-    pub fn shutdown(&self) {
-        self.shutdown.cancel();
-    }
 }
 
 #[cfg(test)]
@@ -581,16 +642,34 @@ mod tests {
         assert!(router.tools_available.load(Ordering::SeqCst));
     }
 
+    #[test]
+    fn test_tools_available_no_auto_reset() {
+        let router = create_test_router();
+        // Simulate a tool call failure by setting flag to false
+        router.tools_available.store(false, Ordering::SeqCst);
+        // The getter should NOT auto-reset
+        assert!(!router.tools_available());
+        // Flag should still be false
+        assert!(!router.tools_available.load(Ordering::SeqCst));
+    }
+
     #[tokio::test]
     async fn test_text_only_fallback() {
-        let router = create_test_router();
+        let proxy_config = ProxyClientConfig {
+            base_url: "http://127.0.0.1:1".to_string(),
+            ..Default::default()
+        };
+        let direct_config = DirectLlmConfig {
+            base_url: Some("http://127.0.0.1:1".to_string()),
+            ..Default::default()
+        };
+        let router = HybridLlmRouter::new(proxy_config, direct_config);
         let messages = vec![Message::user("Hello")];
 
         let response = router.text_only(messages, None).await.unwrap();
-        // When both proxy and direct LLM are unavailable, returns unavailable message
         assert!(
-            response.contains("unavailable") || response.contains("Hello"),
-            "Expected unavailable message or echoed input, got: {}",
+            response.contains("unavailable"),
+            "Expected unavailable message when both proxy and direct LLM are unreachable, got: {}",
             response
         );
     }
@@ -642,4 +721,92 @@ mod tests {
         assert!(response.is_some());
         assert!(response.unwrap().content.contains("Available commands"));
     }
+
+    #[tokio::test]
+    async fn test_compress_fallback_to_extractive() {
+        // Both proxy and Ollama unreachable (port 1 is unreachable)
+        let proxy_config = ProxyClientConfig {
+            base_url: "http://127.0.0.1:1".to_string(),
+            ..Default::default()
+        };
+        let direct_config = DirectLlmConfig {
+            base_url: Some("http://127.0.0.1:1".to_string()),
+            ..Default::default()
+        };
+        let router = HybridLlmRouter::new(proxy_config, direct_config);
+
+        let messages = vec![
+            ChatMessage {
+                role: MessageRole::User,
+                content: "Hello there".to_string(),
+                sender_id: None,
+                timestamp: chrono::Utc::now(),
+                metadata: std::collections::HashMap::new(),
+            },
+            ChatMessage {
+                role: MessageRole::Assistant,
+                content: "Hi! How can I help?".to_string(),
+                sender_id: None,
+                timestamp: chrono::Utc::now(),
+                metadata: std::collections::HashMap::new(),
+            },
+        ];
+
+        let result = router.compress(messages, "system".to_string()).await;
+        assert!(
+            result.is_ok(),
+            "compress should never fail, got: {:?}",
+            result
+        );
+        let summary = result.unwrap();
+        assert!(
+            summary.contains("2 messages"),
+            "Expected extractive summary, got: {}",
+            summary
+        );
+    }
+
+    #[test]
+    fn test_build_proxy_messages_with_summary() {
+        let messages = vec![ChatMessage {
+            role: MessageRole::User,
+            content: "What was the decision?".to_string(),
+            sender_id: None,
+            timestamp: chrono::Utc::now(),
+            metadata: HashMap::new(),
+        }];
+
+        let result = build_proxy_messages(&messages, Some("We decided to use Rust."));
+        // Summary user message + assistant ack + 1 user message = 3
+        assert_eq!(result.len(), 3);
+        assert!(result[0].content.contains("We decided to use Rust."));
+        assert_eq!(result[0].role, "user");
+        assert_eq!(result[1].role, "assistant");
+        assert_eq!(result[2].content, "What was the decision?");
+    }
+
+    #[test]
+    fn test_build_proxy_messages_without_summary() {
+        let messages = vec![
+            ChatMessage {
+                role: MessageRole::User,
+                content: "Hello".to_string(),
+                sender_id: None,
+                timestamp: chrono::Utc::now(),
+                metadata: HashMap::new(),
+            },
+            ChatMessage {
+                role: MessageRole::Assistant,
+                content: "Hi!".to_string(),
+                sender_id: None,
+                timestamp: chrono::Utc::now(),
+                metadata: HashMap::new(),
+            },
+        ];
+
+        let result = build_proxy_messages(&messages, None);
+        assert_eq!(result.len(), 2);
+        assert_eq!(result[0].content, "Hello");
+        assert_eq!(result[1].content, "Hi!");
+    }
 }