add openai chatgpt reasoning effort mapping from config

docs/content/docs/(configuration)/config.mdx

@@ -463,18 +463,27 @@ At least one provider (legacy key or custom provider) must be configured.
 | `compactor` | string | `anthropic/claude-haiku-4.5-20250514` | Model for summarization |
 | `cortex` | string | `anthropic/claude-haiku-4.5-20250514` | Model for system observation |
 | `rate_limit_cooldown_secs` | integer | 60 | How long to deprioritize a rate-limited model |
+| `channel_thinking_effort` | string | `"auto"` | Internal reasoning effort hint for channel model (`"auto"`, `"max"`, `"high"`, `"medium"`, `"low"`) |
+| `branch_thinking_effort` | string | `"auto"` | Internal reasoning effort hint for branch model (`"auto"`, `"max"`, `"high"`, `"medium"`, `"low"`) |
+| `worker_thinking_effort` | string | `"auto"` | Internal reasoning effort hint for worker model (`"auto"`, `"max"`, `"high"`, `"medium"`, `"low"`) |
+| `compactor_thinking_effort` | string | `"auto"` | Internal reasoning effort hint for compactor model (`"auto"`, `"max"`, `"high"`, `"medium"`, `"low"`) |
+| `cortex_thinking_effort` | string | `"auto"` | Internal reasoning effort hint for cortex model (`"auto"`, `"max"`, `"high"`, `"medium"`, `"low"`) |
 
 Routing selects providers by the prefix before the first `/` in the model name.
 
+`*_thinking_effort` is provider-specific:
+- Anthropic adaptive-thinking models use the value directly.
+- `openai-chatgpt/*` models map this to Responses API `reasoning.effort` (`max|high -> high`, `medium -> medium`, `low -> low`, `auto -> omitted`).
+
 ```toml
 [defaults.routing]
-channel = "my_openai/gpt-4o-mini"
-worker = "custom_anthropic/claude-3-5-sonnet"
+channel = "openai-chatgpt/gpt-5.3-codex"
+worker = "openai-chatgpt/gpt-5.3-codex"
+channel_thinking_effort = "high"
+worker_thinking_effort = "medium"
 
-[llm.provider.my_openai]
-api_type = "openai_completions"
-base_url = "https://api.openai.com"
-api_key = "env:OPENAI_API_KEY"
+[llm]
+openai_key = "env:OPENAI_API_KEY"
 
 [llm.provider.custom_anthropic]
 api_type = "anthropic"

prompts/en/branch.md.j2

@@ -28,14 +28,17 @@ Depending on why the channel branched, you might:
 ## Tools
 
 ### memory_recall
-Search for relevant memories. Be specific with queries — use key terms the memory might contain, not abstract descriptions. You'll get curated results ranked by relevance. Use these to inform your conclusion.
+Search for relevant memories. Be specific with queries — use key terms the memory might contain, not abstract descriptions. You'll get curated results ranked by relevance. Use these to inform your conclusion. For recency-oriented asks ("what did we discuss recently?", "last talk"), prefer `mode: "recent"` instead of hybrid.
 
 ### memory_save
 Save something important that came up during your thinking. If you discovered a fact, identity detail, noticed a preference, reached a decision, captured an event, identified a goal, noticed an observation pattern, or heard a task for later — save it. The channel doesn't save memories — that's your job.
 
 ### memory_delete
 Forget a memory by ID. Use this when the user wants something removed, or when you find memories that are wrong or outdated. Get memory IDs from memory_recall results. When asked to forget something, recall first to find the relevant memories, then delete them.
 
+### channel_recall
+Recall transcript history from any channel, including this one. Use this for "what did we talk about last time?" and similar requests where exact conversation history matters. This reads persisted conversation messages, not long-term memory summaries.
+
 ### spacebot_docs
 Read embedded Spacebot docs, including `AGENTS.md`, `CHANGELOG.md`, and product docs from `docs/content/`. Use `action: "list"` to discover IDs, then `action: "read"` for the specific document.
 

prompts/en/tools/memory_recall_description.md.j2

@@ -1 +1 @@
-Search and recall memories from the memory store. Supports multiple search modes: "hybrid" (semantic + keyword + graph search, requires a query), "recent" (most recent memories by time), "important" (highest importance memories), and "typed" (filter by memory type). Default mode is hybrid.
+Search and recall memories from the memory store. Supports multiple search modes: "hybrid" (semantic + keyword + graph search, requires a query), "recent" (most recent memories by time), "important" (highest importance memories), and "typed" (filter by memory type). Default mode is hybrid. For "what did we discuss recently?" style queries, prefer "recent" mode.

src/config.rs

@@ -1854,4 +1854,44 @@ command = "/usr/bin/test"
         // The mcp_servers data is silently dropped — verify it's not accessible
         assert!(parsed.defaults.mcp.is_empty());
     }
+
+    #[test]
+    fn top_level_memory_persistence_is_still_honored() {
+        let _guard = env_test_lock().lock();
+        let guard = EnvGuard::new();
+
+        let toml_content = r#"
+[memory_persistence]
+enabled = true
+message_interval = 7
+"#;
+        let config_path = guard.test_dir.join("config.toml");
+        std::fs::write(&config_path, toml_content).unwrap();
+
+        let config = Config::load_from_path(&config_path).unwrap();
+        assert!(config.defaults.memory_persistence.enabled);
+        assert_eq!(config.defaults.memory_persistence.message_interval, 7);
+    }
+
+    #[test]
+    fn defaults_memory_persistence_overrides_top_level_legacy() {
+        let _guard = env_test_lock().lock();
+        let guard = EnvGuard::new();
+
+        let toml_content = r#"
+[memory_persistence]
+enabled = false
+message_interval = 99
+
+[defaults.memory_persistence]
+enabled = true
+message_interval = 5
+"#;
+        let config_path = guard.test_dir.join("config.toml");
+        std::fs::write(&config_path, toml_content).unwrap();
+
+        let config = Config::load_from_path(&config_path).unwrap();
+        assert!(config.defaults.memory_persistence.enabled);
+        assert_eq!(config.defaults.memory_persistence.message_interval, 5);
+    }
 }

src/config/load.rs

@@ -69,6 +69,7 @@ pub fn set_resolve_secrets_store(store: std::sync::Arc<crate::secrets::store::Se
 const KNOWN_TOP_LEVEL_KEYS: &[&str] = &[
     "llm",
     "defaults",
+    "memory_persistence",
     "agents",
     "links",
     "groups",
@@ -90,6 +91,15 @@ pub(super) fn warn_unknown_config_keys(content: &str) {
     };
 
     for key in table.keys() {
+        if key == "memory_persistence" {
+            tracing::warn!(
+                "config.toml contains top-level key `memory_persistence`. \
+                 This legacy location is still supported, but prefer \
+                 [defaults.memory_persistence] for new configs."
+            );
+            continue;
+        }
+
         if KNOWN_TOP_LEVEL_KEYS.contains(&key.as_str()) {
             continue;
         }
@@ -1403,6 +1413,7 @@ impl Config {
             memory_persistence: toml
                 .defaults
                 .memory_persistence
+                .or(toml.memory_persistence)
                 .map(|mp| MemoryPersistenceConfig {
                     enabled: mp
                         .enabled

src/config/toml_schema.rs

@@ -10,6 +10,8 @@ pub(super) struct TomlConfig {
     #[serde(default)]
     pub(super) defaults: TomlDefaultsConfig,
     #[serde(default)]
+    pub(super) memory_persistence: Option<TomlMemoryPersistenceConfig>,
+    #[serde(default)]
     pub(super) agents: Vec<TomlAgentConfig>,
     #[serde(default)]
     pub(super) links: Vec<TomlLinkDef>,

src/llm/model.rs

@@ -545,18 +545,33 @@ impl CompletionModel for SpacebotModel {
 }
 
 impl SpacebotModel {
+    fn configured_thinking_effort(&self) -> &str {
+        let Some(routing) = self.routing.as_ref() else {
+            return "auto";
+        };
+
+        if let Some(process_type) = self.process_type.as_deref() {
+            return match process_type {
+                "channel" => routing.channel_thinking_effort.as_str(),
+                "branch" => routing.branch_thinking_effort.as_str(),
+                "worker" => routing.worker_thinking_effort.as_str(),
+                "compactor" => routing.compactor_thinking_effort.as_str(),
+                "cortex" => routing.cortex_thinking_effort.as_str(),
+                _ => routing.thinking_effort_for_model(&self.model_name),
+            };
+        }
+
+        routing.thinking_effort_for_model(&self.model_name)
+    }
+
     async fn call_anthropic(
         &self,
         request: CompletionRequest,
         provider_config: &ProviderConfig,
     ) -> Result<completion::CompletionResponse<RawResponse>, CompletionError> {
         let api_key = provider_config.api_key.as_str();
 
-        let effort = self
-            .routing
-            .as_ref()
-            .map(|r| r.thinking_effort_for_model(&self.model_name))
-            .unwrap_or("auto");
+        let effort = self.configured_thinking_effort();
         let anthropic_request = crate::llm::anthropic::build_anthropic_request(
             self.llm_manager.http_client(),
             api_key,
@@ -766,6 +781,12 @@ impl SpacebotModel {
             body["stream"] = serde_json::json!(true);
         }
 
+        if self.provider == "openai-chatgpt"
+            && let Some(effort) = map_openai_reasoning_effort(self.configured_thinking_effort())
+        {
+            body["reasoning"] = serde_json::json!({ "effort": effort });
+        }
+
         if !request.tools.is_empty() {
             let tools: Vec<serde_json::Value> = request
                 .tools
@@ -2859,6 +2880,16 @@ fn provider_display_name(provider_id: &str) -> String {
     }
 }
 
+fn map_openai_reasoning_effort(config_effort: &str) -> Option<&'static str> {
+    match config_effort.trim().to_ascii_lowercase().as_str() {
+        "auto" => None,
+        "max" | "high" => Some("high"),
+        "medium" => Some("medium"),
+        "low" | "minimal" => Some("low"),
+        _ => None,
+    }
+}
+
 fn remap_model_name_for_api(provider: &str, model_name: &str) -> String {
     if provider == "zai-coding-plan" {
         // Coding Plan endpoint expects plain model ids (e.g. "glm-5").
@@ -2916,6 +2947,18 @@ mod tests {
             panic!("expected ToolCall");
         }
     }
+
+    #[test]
+    fn map_openai_reasoning_effort_maps_values() {
+        assert_eq!(map_openai_reasoning_effort("auto"), None);
+        assert_eq!(map_openai_reasoning_effort("max"), Some("high"));
+        assert_eq!(map_openai_reasoning_effort("high"), Some("high"));
+        assert_eq!(map_openai_reasoning_effort("medium"), Some("medium"));
+        assert_eq!(map_openai_reasoning_effort("low"), Some("low"));
+        assert_eq!(map_openai_reasoning_effort("minimal"), Some("low"));
+        assert_eq!(map_openai_reasoning_effort("invalid"), None);
+    }
+
     #[test]
     fn coding_plan_model_name_uses_plain_glm_id() {
         assert_eq!(