fix: resolve 6 CLI-side API issues from platform analysis

- #3: Handle missing usage in Google SSE (fallback to input_tokens/output_tokens)
- #4: Fix support ticket URL double /api/v1, use correct field names
- #5: Add retry-with-backoff for upstream 429s in LLM client
- #6: Fix README discourse events → turns
- #9: Skip TUI launch if binary not found (check first, don't try/catch)
- Marketplace: align struct with actual API response fields

571 tests pass, 0 clippy warnings.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Darth-Hidious

README.md

@@ -131,7 +131,7 @@ prism models info <model-id>         # Show model details
 prism discourse create --spec spec.yaml           # Create a discourse
 prism discourse list                               # List discourses
 prism discourse status <id>                        # Check discourse status
-prism discourse events <id>                        # Stream discourse events
+prism discourse turns <id>                         # View discourse turns
 ```
 
 ### Deploy

crates/cli/src/main.rs

@@ -751,19 +751,18 @@ async fn main() -> Result<()> {
                     }
                 }
             }
-            // TUI is currently out of commission — guide user to CLI commands
-            match launch_tui(&paths, &python, &project_root, state.credentials.as_ref()) {
-                Ok(()) => {}
-                Err(_) => {
-                    println!("\n  PRISM v{}", env!("CARGO_PKG_VERSION"));
-                    println!("  The interactive TUI is not available in this build.\n");
-                    println!("  Use CLI commands directly:");
-                    println!("    prism query --platform \"nickel superalloys\"");
-                    println!("    prism research \"high entropy alloys\" --depth 1");
-                    println!("    prism ingest ./data.csv");
-                    println!("    prism models list");
-                    println!("    prism --help\n");
-                }
+            // Skip TUI launch entirely if binary doesn't exist
+            if discover_tui_binary(&paths).is_some() {
+                launch_tui(&paths, &python, &project_root, state.credentials.as_ref())?;
+            } else {
+                println!("\n  PRISM v{}", env!("CARGO_PKG_VERSION"));
+                println!("  The interactive TUI is not available in this build.\n");
+                println!("  Use CLI commands directly:");
+                println!("    prism query --platform \"nickel superalloys\"");
+                println!("    prism research \"high entropy alloys\" --depth 1");
+                println!("    prism ingest ./data.csv");
+                println!("    prism models list");
+                println!("    prism --help\n");
             }
         }
         Commands::Login => {
@@ -1808,11 +1807,6 @@ async fn main() -> Result<()> {
                     } else {
                         println!("Marketplace resources:\n");
                         for t in &tools {
-                            let tags = if t.tags.is_empty() {
-                                String::new()
-                            } else {
-                                format!("  [{}]", t.tags.join(", "))
-                            };
                             let author = t.author.as_deref().unwrap_or("MARC27");
                             println!(
                                 "  {} ({})  by {}  [{}]",
@@ -5321,8 +5315,8 @@ async fn handle_report(
     let user_name = creds
         .and_then(|c| c.display_name.as_deref())
         .unwrap_or("anonymous");
-    let user_id = creds.and_then(|c| c.user_id.as_deref()).unwrap_or("");
-    let project_id = creds.and_then(|c| c.project_id.as_deref()).unwrap_or("");
+    let _user_id = creds.and_then(|c| c.user_id.as_deref()).unwrap_or("");
+    let _project_id = creds.and_then(|c| c.project_id.as_deref()).unwrap_or("");
 
     // 2. Build the report body
     let mut body = format!(
@@ -5387,20 +5381,15 @@ async fn handle_report(
         if !c.access_token.is_empty() {
             print!("Sending to MARC27 platform... ");
             let platform_body = serde_json::json!({
-                "type": "bug_report",
-                "description": description,
-                "prism_version": version,
-                "python_version": python_version,
-                "os": os_info,
-                "cpu_cores": caps.cpu_cores,
-                "ram_gb": caps.ram_gb / 1024,
-                "docker": caps.docker,
-                "log": log_content,
-                "user_id": user_id,
-                "project_id": project_id,
+                "title": format!("bug report: {}", &description[..description.len().min(60)]),
+                "description": format!(
+                    "{description}\n\nPRISM v{version}, Python {python_version}, {os_info}, {} cores, {} GB RAM",
+                    caps.cpu_cores, caps.ram_gb / 1024,
+                ),
+                "severity": "medium",
             });
 
-            let url = format!("{}/api/v1/support/tickets", endpoints.api_base);
+            let url = format!("{}/support/tickets", endpoints.api_base);
             let resp = reqwest::Client::new()
                 .post(&url)
                 .header("Authorization", format!("Bearer {}", c.access_token))

crates/ingest/src/llm.rs

@@ -297,10 +297,17 @@ impl LlmClient {
                         }
                     }
                     if let Some(u) = chunk.get("usage") {
-                        if let (Some(pt), Some(ct)) = (
-                            u.get("prompt_tokens").and_then(|v| v.as_u64()),
-                            u.get("completion_tokens").and_then(|v| v.as_u64()),
-                        ) {
+                        let pt = u
+                            .get("prompt_tokens")
+                            .or_else(|| u.get("input_tokens"))
+                            .and_then(|v| v.as_u64())
+                            .unwrap_or(0);
+                        let ct = u
+                            .get("completion_tokens")
+                            .or_else(|| u.get("output_tokens"))
+                            .and_then(|v| v.as_u64())
+                            .unwrap_or(0);
+                        if pt > 0 || ct > 0 {
                             usage_info = Some(UsageInfo {
                                 prompt_tokens: pt,
                                 completion_tokens: ct,
@@ -500,6 +507,44 @@ impl LlmClient {
 
     async fn post(&self, url: &str, body: &serde_json::Value) -> Result<reqwest::Response> {
         debug!(%url, "LLM request");
+        for attempt in 0..3u32 {
+            let mut req = self.client.post(url).json(body);
+            if let Some(auth) = self.auth_header() {
+                req = req.header("Authorization", auth);
+            }
+            let resp = req
+                .send()
+                .await
+                .with_context(|| format!("LLM request to {url} failed"))?;
+            if resp.status() == reqwest::StatusCode::TOO_MANY_REQUESTS {
+                let wait = resp
+                    .headers()
+                    .get("retry-after")
+                    .and_then(|v| v.to_str().ok())
+                    .and_then(|s| s.parse::<u64>().ok())
+                    .unwrap_or(2u64.pow(attempt));
+                debug!(attempt, wait_secs = wait, "429 — retrying after backoff");
+                tokio::time::sleep(Duration::from_secs(wait)).await;
+                continue;
+            }
+            if !resp.status().is_success() {
+                let status = resp.status();
+                let text = resp.text().await.unwrap_or_default();
+                bail!("LLM returned HTTP {status}: {text}");
+            }
+            return Ok(resp);
+        }
+        bail!("LLM request to {url} failed after 3 retries (429 rate limit)");
+    }
+
+    // Keep old signature for callers that held the single-attempt path
+    #[allow(dead_code)]
+    async fn post_no_retry(
+        &self,
+        url: &str,
+        body: &serde_json::Value,
+    ) -> Result<reqwest::Response> {
+        debug!(%url, "LLM request (no retry)");
         let mut req = self.client.post(url).json(body);
         if let Some(auth) = self.auth_header() {
             req = req.header("Authorization", auth);