fix: harden initialized config and REPL status

Author: dollspace-field

src/claude_credentials.rs

@@ -641,6 +641,8 @@ pub struct CredentialStatus {
     pub has_inference_scope: bool,
     /// Recorded subscription type, when present.
     pub subscription_type: Option<String>,
+    /// Recorded rate-limit tier, when present.
+    pub rate_limit_tier: Option<String>,
 }
 
 /// Inspect the shared Claude credential store without refreshing tokens.
@@ -676,6 +678,7 @@ fn status_from_oauth(oauth: &ClaudeAiOauth, now_ms: i64) -> CredentialStatus {
         expires_soon: now_ms < oauth.expires_at && now_ms + REFRESH_BUFFER_MS >= oauth.expires_at,
         has_inference_scope: oauth.scopes.iter().any(|scope| scope == "user:inference"),
         subscription_type: oauth.subscription_type.clone(),
+        rate_limit_tier: oauth.rate_limit_tier.clone(),
     }
 }
 
@@ -1128,6 +1131,7 @@ mod tests {
         assert!(!far.expires_soon);
         assert!(far.has_inference_scope);
         assert_eq!(far.subscription_type.as_deref(), Some("pro"));
+        assert_eq!(far.rate_limit_tier, None);
 
         let expired = ClaudeAiOauth {
             expires_at: 100,

src/cli/commands/init.rs

@@ -129,11 +129,12 @@ providers:
   opencode:
     base_url: https://opencode.ai/zen/go/v1
     # api_key: ${OPENCODE_API_KEY}  # or ${OPENCODE_GO_API_KEY}
-  # Generic remote OpenAI-compatible endpoint
-  openai-compatible:
-    base_url: https://api.example.com/v1
-    # api_key: ${OPENAI_COMPATIBLE_API_KEY}
-    # model: my-model-name
+  # Generic remote OpenAI-compatible endpoint. Uncomment and replace the
+  # placeholder before selecting `openai-compatible` as the proxy target.
+  # openai-compatible:
+  #   base_url: https://your-provider.example/v1
+  #   api_key: ${OPENAI_COMPATIBLE_API_KEY}
+  #   model: my-model-name
   # Ollama for local LLM inference
   ollama:
     base_url: http://localhost:11434

src/cli/repl/slash.rs

@@ -1353,46 +1353,37 @@ pub fn slash_context(messages: &[serde_json::Value], current_model: &str) -> Sla
 }
 
 pub fn slash_login() -> SlashCommandResult {
-    if openclaudia::claude_credentials::has_claude_code_credentials() {
-        println!("\n✓ Authenticated via Claude Code credentials.");
-        println!("  File: ~/.claude/.credentials.json");
-        // crosslink #932: previously this used `Handle::current()` which
-        // panics when called outside a runtime. `try_current` mirrors the
-        // pattern used by `slash_model` above. When called from a worker
-        // thread that is itself driving the runtime, `block_on` would also
-        // panic — degrade gracefully to "details unavailable" rather than
-        // crashing the REPL.
-        match tokio::runtime::Handle::try_current() {
-            Ok(handle) => {
-                let load_result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
-                    handle.block_on(openclaudia::claude_credentials::load_credentials())
-                }));
-                if let Ok(Ok(creds)) = load_result {
-                    println!(
-                        "  Type: {}",
-                        creds.subscription_type.as_deref().unwrap_or("unknown")
-                    );
-                    println!(
-                        "  Tier: {}",
-                        creds.rate_limit_tier.as_deref().unwrap_or("default")
-                    );
-                } else {
-                    println!(
-                        "  (credential details unavailable — cannot block on current runtime)"
-                    );
-                }
-            }
-            Err(_) => {
-                println!("  (credential details unavailable — no tokio runtime active)");
+    match openclaudia::claude_credentials::peek_credentials() {
+        Ok(Some(status)) => {
+            println!("\n✓ Authenticated via Claude Code credentials.");
+            println!("  File: ~/.claude/.credentials.json");
+            println!(
+                "  Type: {}",
+                status.subscription_type.as_deref().unwrap_or("unknown")
+            );
+            println!(
+                "  Tier: {}",
+                status.rate_limit_tier.as_deref().unwrap_or("default")
+            );
+            if status.expired {
+                println!("  Status: expired (auto-refreshes on next use)");
+            } else if status.expires_soon {
+                println!("  Status: valid, expiring soon");
+            } else {
+                println!("  Status: valid");
             }
         }
-    } else {
-        println!("\n✗ Not authenticated via Claude Code.");
-        println!("  To log in:");
-        println!("  1. Install Claude Code: npm install -g @anthropic-ai/claude-code");
-        println!("  2. Run: claude");
-        println!("  3. Complete the login flow");
-        println!("  4. Restart OpenClaudia");
+        Ok(None) => {
+            println!("\n✗ Not authenticated via Claude Code.");
+            println!("  To log in:");
+            println!("  1. Install Claude Code: npm install -g @anthropic-ai/claude-code");
+            println!("  2. Run: claude");
+            println!("  3. Complete the login flow");
+            println!("  4. Restart OpenClaudia");
+        }
+        Err(error) => {
+            println!("\n✗ Could not read Claude Code credentials: {error}");
+        }
     }
     println!();
     SlashCommandResult::Handled

src/slash_commands.rs

@@ -113,9 +113,12 @@ const CORE: &[SlashCommand] = &[
 const MEMORY: &[SlashCommand] = &[
     cmd("/memory", "Show auto-learning stats"),
     cmd("/memory patterns", "Show learned coding patterns"),
-    cmd("/memory errors", "Show known error patterns"),
+    cmd("/memory errors <path>", "Show known errors for a file"),
     cmd("/memory prefs", "Show learned preferences"),
-    cmd("/memory files", "Show file co-edit relationships"),
+    cmd(
+        "/memory files <path>",
+        "Show co-edit relationships for a file",
+    ),
     cmd(
         "/memory reset",
         "Reset all learned data (with confirmation)",
@@ -442,6 +445,23 @@ mod tests {
         }
     }
 
+    #[test]
+    fn memory_file_queries_advertise_required_paths() {
+        let invocations: Vec<&str> = all_commands().map(|c| c.invocation).collect();
+        for invocation in ["/memory errors <path>", "/memory files <path>"] {
+            assert!(
+                invocations.contains(&invocation),
+                "memory query must advertise its required path: {invocation}"
+            );
+        }
+        for stale in ["/memory errors", "/memory files"] {
+            assert!(
+                !invocations.contains(&stale),
+                "memory query must not advertise an argument-free form: {stale}"
+            );
+        }
+    }
+
     #[test]
     fn tui_table_excludes_legacy_repl_only_commands() {
         let invocations: Vec<&str> = all_tui_commands().map(|c| c.invocation).collect();

tests/cli_exit_status_e2e.rs

@@ -180,6 +180,56 @@ fn run_auth_with_stdin(input: &str) -> Output {
     child.wait_with_output().expect("openclaudia auth must run")
 }
 
+#[test]
+fn legacy_repl_login_reads_status_without_nesting_a_runtime() {
+    let cwd = tempfile::tempdir().expect("cwd tempdir");
+    let home = tempfile::tempdir().expect("home tempdir");
+    write_local_provider_config(&cwd);
+    write_claude_oauth_credentials(&home.path().join(".claude"));
+
+    let mut child = isolated_command(&cwd, &home)
+        .args([
+            "--tui-mode",
+            "--dangerously-skip-permissions",
+            "--target",
+            "local",
+            "--model",
+            "local-test-model",
+        ])
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .expect("legacy REPL must spawn");
+    child
+        .stdin
+        .take()
+        .expect("legacy REPL stdin")
+        .write_all(b"/login\n/exit\n")
+        .expect("legacy REPL should accept slash commands");
+
+    let output = child.wait_with_output().expect("legacy REPL must exit");
+    let combined = format!(
+        "{}{}",
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr)
+    );
+    assert!(
+        output.status.success(),
+        "legacy REPL should exit cleanly after /login; got {combined:?}"
+    );
+    assert!(
+        combined.contains("Authenticated via Claude Code credentials")
+            && combined.contains("Type: max")
+            && combined.contains("Tier: max"),
+        "/login should report synchronous credential status; got {combined:?}"
+    );
+    assert!(
+        !combined.contains("panicked") && !combined.contains("Cannot start a runtime"),
+        "/login must not attempt to nest a Tokio runtime; got {combined:?}"
+    );
+}
+
 fn readme_cli_command_invocations() -> Vec<String> {
     let readme = include_str!("../README.md");
     let section = readme
@@ -2707,6 +2757,17 @@ fn init_refuses_overwrite_unless_force_and_creates_documented_tree() {
         config.contains("OpenClaudia Configuration") && !config.contains("sentinel"),
         "init --force must replace the previous config contents"
     );
+
+    let output = isolated_command(&cwd, &home)
+        .arg("config")
+        .output()
+        .expect("openclaudia config must run after init");
+    assert!(
+        output.status.success(),
+        "the generated config must load without edits; stdout={:?} stderr={:?}",
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr)
+    );
 }
 
 #[cfg(unix)]