config: unify subconscious API resolution with the main chat path

Two parallel backend-resolution paths had drifted apart:

- Main chat: AppConfig::resolve_model() → a named BackendConfig in
  AppConfig.backends
- Subconscious / oneshot / context_window(): four skip-serde
  "cache" fields on Config (memory section) — api_base_url, api_key,
  api_model, api_context_window — that used to be populated at
  Config::try_load_shared time by walking memory.agent_model →
  root.models[name] → root[backend_name]

When we renamed `models` to `backends` and collapsed ModelConfig into
BackendConfig, the latter chain started silently dereferencing
`root.get("models")` → None → no population. Subconscious agents fell
through the "API not configured" guard; context_window() started
returning 0 (since api_context_window default is u64's 0 now that we
don't populate it). It was only visibly working for the main chat.

Collapse to one path:

- Drop Config.agent_model (duplicate of AppConfig.default_backend)
- Drop Config.{api_base_url, api_key, api_model, api_context_window}
  — no longer populated, no longer needed
- Drop default_context_window() — nobody reads the field anymore
- Drop the memory-side resolution block in try_load_shared()
- Subconscious (mind/unconscious.rs) and oneshot (agent/oneshot.rs)
  now call load_app() + resolve_model(&app.default_backend) just like
  the main chat does
- context_window() reads from config::app().backends[default_backend]
  .context_window, defaulting to 128k only if the backend doesn't
  specify one

Side effect: Kent's config file drops agent_model, api_reasoning,
journal_days, journal_max — all fields whose Rust counterparts are
now gone. (Figment tolerates unknown fields, so leaving them wouldn't
have broken anything, but they were lying about what's configurable.)

Co-Authored-By: Proof of Concept <poc@bcachefs.org>

src/config.rs

@@ -26,7 +26,6 @@ pub fn config_path() -> PathBuf {
 
 static CONFIG: OnceLock<RwLock<Arc<Config>>> = OnceLock::new();
 
-fn default_context_window() -> usize { 128_000 }
 fn default_stream_timeout() -> u64 { 60 }
 fn default_scoring_interval_secs() -> u64 { 3600 } // 1 hour
 fn default_scoring_response_window() -> usize { 100 }
@@ -60,18 +59,6 @@ pub struct Config {
     pub agent_nodes: Vec<String>,
     pub llm_concurrency: usize,
     pub agent_budget: usize,
-    /// Resolved from agent_model → models → backend (not in config directly)
-    #[serde(skip)]
-    pub api_base_url: Option<String>,
-    #[serde(skip)]
-    pub api_key: Option<String>,
-    #[serde(skip)]
-    pub api_model: Option<String>,
-    #[serde(skip, default = "default_context_window")]
-    pub api_context_window: usize,
-    /// Used to resolve API settings, not stored on Config
-    #[serde(default)]
-    agent_model: Option<String>,
     /// Stream chunk timeout in seconds (no data = timeout).
     #[serde(default = "default_stream_timeout")]
     pub api_stream_timeout_secs: u64,
@@ -115,14 +102,9 @@ impl Default for Config {
             agent_nodes: vec!["identity".into(), "core-practices".into()],
             llm_concurrency: 1,
             agent_budget: 1000,
-            api_base_url: None,
-            api_key: None,
-            api_model: None,
-            api_context_window: default_context_window(),
             api_stream_timeout_secs: default_stream_timeout(),
             scoring_interval_secs: default_scoring_interval_secs(),
             scoring_response_window: default_scoring_response_window(),
-            agent_model: None,
             agent_types: vec![
                 "linker".into(), "organize".into(), "distill".into(),
                 "separator".into(), "split".into(),
@@ -153,25 +135,7 @@ impl Config {
         let mut config: Config = serde_json::from_value(mem_value.clone()).ok()?;
         config.llm_concurrency = config.llm_concurrency.max(1);
 
-        // Resolve API settings: agent_model → models → backend
-        if let Some(model_name) = &config.agent_model
-            && let Some(model_cfg) = root.get("models").and_then(|m| m.get(model_name.as_str())) {
-                let backend_name = model_cfg.get("backend").and_then(|v| v.as_str()).unwrap_or("");
-                let model_id = model_cfg.get("model_id").and_then(|v| v.as_str()).unwrap_or("");
-
-                if let Some(backend) = root.get(backend_name) {
-                    config.api_base_url = backend.get("base_url")
-                        .and_then(|v| v.as_str()).map(String::from);
-                    config.api_key = backend.get("api_key")
-                        .and_then(|v| v.as_str()).map(String::from);
-                }
-                config.api_model = Some(model_id.to_string());
-                if let Some(cw) = model_cfg.get("context_window").and_then(|v| v.as_u64()) {
-                    config.api_context_window = cw as usize;
-                }
-            }
-
-        // Top-level config sections (not inside "memory")
+        // Top-level sections (not inside "memory").
         if let Some(servers) = root.get("lsp_servers") {
             config.lsp_servers = serde_json::from_value(servers.clone()).unwrap_or_default();
         }