rc.6

Author: gglucass

README.md

@@ -66,8 +66,9 @@ If the proxy dies unexpectedly, a watchdog restarts it; after repeated failures
 | Tool | What it does | Default |
 |------|-------------|---------|
 | [headroom](https://pypi.org/project/headroom-ai/) | Prompt optimization pipeline (Python) | Required |
-| [rtk](https://github.com/gglucass/rtk) | Rewrites Claude Code bash commands to strip noise before it reaches the context window | Auto-enabled |
-| vitals | Project health scanner — flags stale deps, large files, drift | Included |
+| [rtk](https://github.com/gglucass/rtk) | Rewrites Claude Code bash commands to strip noise before it reaches the context window | Opt-in add-on |
+| [markitdown](https://github.com/microsoft/markitdown) | Converts PDFs and Office documents to clean Markdown before the agent reads them | Opt-in add-on |
+| ponytail | Nudges the agent toward leaner, less over-engineered code | Opt-in add-on |
 
 **Tool inclusion policy:** only tools that run entirely locally, inside Headroom-managed storage, with a stable CLI surface make it in. No cloud dependencies, no host profile mutations. See [`research/tool-compatibility-matrix.md`](research/tool-compatibility-matrix.md).
 

docs/beta-smoke-test.md

@@ -28,9 +28,9 @@ Expect: mtime within the last minute. `lastTransformation` inside the file is a
 
 ### 3. RTK is on PATH and reports savings (Claude Code only — RTK does not rewrite Codex)
 ```bash
-rtk --version && rtk gain | head -5
+zsh -lc 'rtk --version && rtk gain | head -5'
 ```
-Expect: a version line and a gain summary, no "command not found".
+Expect: a version line and a gain summary, no "command not found". The `zsh -lc` wrapper is required: `rtk` is added to PATH by the `headroom:managed_rtk` block in `~/.zprofile`, which only a login shell sources. Claude Code's Bash tool (and Codex's shell tool) spawn a non-login, non-interactive shell that does *not* source it, so a bare `rtk` here reports `command not found` on a perfectly healthy install. A login shell exercises the same PATH wiring a real terminal gets, so this confirms both that the managed block is intact and that the binary runs.
 
 ### 4. MCP retrieve tool is available (Claude Code only; only if memory tools are enabled)
 First check whether the proxy was started with memory tools:
@@ -164,6 +164,12 @@ When inspecting the running proxy by hand (e.g. checking `/stats`), wrap `curl`
 rtk proxy curl -s http://127.0.0.1:6767/stats | jq .summary
 ```
 
+Every `rtk` invocation in this doc (checks 3, 7, C2, and above) has the same PATH caveat as check 3: when Claude Code or Codex runs them through their shell tool, `rtk` is not on PATH because the non-login shell never sources `~/.zprofile`. Either wrap the command in `zsh -lc '...'`, or call the binary by its managed path:
+
+```bash
+"$HOME/Library/Application Support/Headroom/headroom/bin/rtk" proxy curl -s http://127.0.0.1:6767/stats | jq .summary
+```
+
 ## When something fails
 
 - Proxy log silent → check `~/Library/Application Support/Headroom/headroom/logs/` for a newer log file or a crash file.

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "headroom-desktop",
-  "version": "0.4.6-rc.5",
+  "version": "0.4.6-rc.6",
   "private": true,
   "type": "module",
   "scripts": {

package.json

@@ -1,6 +1,6 @@
 [package]
 name = "headroom-desktop"
-version = "0.4.6-rc.5"
+version = "0.4.6-rc.6"
 description = "Headroom v1 local-first LLM optimization tray app"
 authors = ["Codex"]
 license = "MIT"

src-tauri/Cargo.lock

@@ -319,16 +319,19 @@ pub fn verify_client_setup(client_id: &str) -> Result<ClientSetupVerification> {
                         .into(),
                 );
             }
-            // RTK is a separate, user-toggleable integration (`set_rtk_enabled`
-            // tears it down without touching ANTHROPIC_BASE_URL routing). When
-            // the user has deliberately disabled RTK, its absence must not fail
-            // Claude Code verification — routing is what "connected" means here.
-            if !state.rtk_disabled && !rtk_path_ok {
+            // RTK is a separate, opt-in integration (`set_rtk_enabled` tears it
+            // down without touching ANTHROPIC_BASE_URL routing). Its wiring is
+            // only ever added when the managed binary exists on disk (see
+            // `ensure_rtk_integrations_for_targets`), so its absence must not
+            // fail Claude Code verification when RTK isn't installed or the user
+            // disabled it — routing is what "connected" means here.
+            let rtk_required = !state.rtk_disabled && default_headroom_rtk_path().exists();
+            if rtk_required && !rtk_path_ok {
                 failures.push(
                     "Headroom-managed RTK PATH export was not found in shell profiles.".into(),
                 );
             }
-            if !state.rtk_disabled && !rtk_hook_ok {
+            if rtk_required && !rtk_hook_ok {
                 failures.push(
                     "Headroom-managed RTK Claude hook was not found in ~/.claude/settings.json."
                         .into(),
@@ -4069,6 +4072,46 @@ export ANTHROPIC_BASE_URL=http://127.0.0.1:6767
         );
     }
 
+    #[test]
+    #[serial_test::serial]
+    fn verify_claude_code_passes_when_rtk_not_installed() {
+        let home = TestHome::new();
+        fs::write(home.path().join(".zshrc"), "# user zshrc\n").unwrap();
+        fs::write(home.path().join(".zshenv"), "# user zshenv\n").unwrap();
+        fs::create_dir_all(home.path().join(".claude")).unwrap();
+        fs::write(
+            home.path().join(".claude").join("settings.json"),
+            r#"{"hooks": {}}"#,
+        )
+        .unwrap();
+
+        // Clean install with RTK auto-install removed: routing is configured but
+        // the managed RTK binary was never dropped on disk and the user never
+        // toggled RTK off (rtk_disabled stays false). Claude Code must still
+        // verify green on routing alone.
+        super::apply_client_setup("claude_code").expect("apply_client_setup succeeds");
+
+        assert!(
+            !super::default_headroom_rtk_path().exists(),
+            "RTK binary must be absent for this test"
+        );
+        let state = super::load_setup_state();
+        assert!(!state.rtk_disabled, "rtk_disabled stays false when untoggled");
+
+        let verification =
+            super::verify_client_setup("claude_code").expect("verify_client_setup succeeds");
+        assert!(
+            verification.verified,
+            "claude_code verifies on routing alone when RTK isn't installed, failures: {:?}",
+            verification.failures
+        );
+        assert!(
+            verification.failures.iter().all(|f| !f.contains("RTK")),
+            "no RTK failures reported when RTK isn't installed, got: {:?}",
+            verification.failures
+        );
+    }
+
     #[test]
     #[serial_test::serial]
     fn ensure_rtk_integrations_writes_codex_nudge_and_disable_removes_it() {

src-tauri/Cargo.toml

@@ -627,7 +627,7 @@ fn show_notification_impl(
 }
 
 #[tauri::command]
-fn install_addon(state: State<'_, AppState>, id: String) -> Result<DashboardState, String> {
+async fn install_addon(state: State<'_, AppState>, id: String) -> Result<DashboardState, String> {
     match id.as_str() {
         "markitdown" => {
             state
@@ -667,7 +667,7 @@ fn install_addon(state: State<'_, AppState>, id: String) -> Result<DashboardStat
 }
 
 #[tauri::command]
-fn set_addon_enabled(
+async fn set_addon_enabled(
     state: State<'_, AppState>,
     id: String,
     enabled: bool,
@@ -705,7 +705,7 @@ fn set_addon_enabled(
 }
 
 #[tauri::command]
-fn uninstall_addon(state: State<'_, AppState>, id: String) -> Result<DashboardState, String> {
+async fn uninstall_addon(state: State<'_, AppState>, id: String) -> Result<DashboardState, String> {
     match id.as_str() {
         "markitdown" => {
             let _ = client_adapters::disable_markitdown_integration(
@@ -1951,6 +1951,10 @@ fn get_headroom_request_count() -> Option<u64> {
 }
 
 fn fetch_proxy_request_count_stats() -> Option<u64> {
+    parse_request_count_from_stats_body(&fetch_proxy_stats_body()?)
+}
+
+fn fetch_proxy_stats_body() -> Option<String> {
     let client = reqwest::blocking::Client::builder()
         .timeout(std::time::Duration::from_millis(500))
         .build()
@@ -1963,14 +1967,43 @@ fn fetch_proxy_request_count_stats() -> Option<u64> {
         if !response.status().is_success() {
             continue;
         }
-        let Ok(body) = response.text() else { continue };
-        if let Some(count) = parse_request_count_from_stats_body(&body) {
-            return Some(count);
+        if let Ok(body) = response.text() {
+            return Some(body);
         }
     }
     None
 }
 
+/// Per-agent request counts from `/stats` `agent_usage.agents[]`, keyed by the
+/// proxy's agent id (`claude-code`, `codex`, ...). Used by setup verification
+/// so a prompt sent to one client only flips that client's row, not all rows.
+#[tauri::command]
+fn get_headroom_request_counts_by_agent() -> Option<std::collections::HashMap<String, u64>> {
+    parse_request_counts_by_agent(&fetch_proxy_stats_body()?)
+}
+
+pub(crate) fn parse_request_counts_by_agent(
+    body: &str,
+) -> Option<std::collections::HashMap<String, u64>> {
+    let root = serde_json::from_str::<serde_json::Value>(body).ok()?;
+    let mut counts = std::collections::HashMap::new();
+    if let Some(agents) = root
+        .get("agent_usage")
+        .and_then(|v| v.get("agents"))
+        .and_then(|v| v.as_array())
+    {
+        for agent in agents {
+            if let (Some(key), Some(requests)) = (
+                agent.get("agent").and_then(|v| v.as_str()),
+                agent.get("requests").and_then(|v| v.as_u64()),
+            ) {
+                counts.insert(key.to_string(), requests);
+            }
+        }
+    }
+    Some(counts)
+}
+
 /// Pull `requests.total` (or any of the legacy spellings) out of a /stats
 /// JSON body. Mirrors the lookup in `state::parse_headroom_stats_from_json`
 /// but trimmed to just the counter we need for verification.
@@ -3278,6 +3311,7 @@ pub fn run() {
             get_runtime_status,
             get_headroom_logs,
             get_headroom_request_count,
+            get_headroom_request_counts_by_agent,
             get_rtk_activity,
             get_tool_logs,
             get_claude_code_projects,
@@ -5170,7 +5204,8 @@ mod tests {
         is_disk_full_signal, is_endpoint_protection_signal, is_network_download_signal,
         is_port_conflict_failure, is_prerelease_version, lifetime_token_milestone_kind,
         noop_app_update_progress_emitter, parse_live_learnings,
-        parse_request_count_from_stats_body, parse_updater_endpoint_list, pattern_matches_project,
+        parse_request_count_from_stats_body, parse_request_counts_by_agent,
+        parse_updater_endpoint_list, pattern_matches_project,
         physical_rect_from_rect, read_applied_patterns_for_project, readyz_failed_checks_csv,
         readyz_failure_has_core_unhealthy, readyz_failure_is_upstream_only,
         resolve_release_updater_config, select_updater_endpoints, store_checked_update,
@@ -6534,6 +6569,29 @@ Some unrelated content.
         assert_eq!(parse_request_count_from_stats_body("not json"), None);
     }
 
+    #[test]
+    fn parse_request_counts_by_agent_keys_by_agent_id() {
+        let body = json!({
+            "agent_usage": {
+                "agents": [
+                    { "agent": "claude-code", "requests": 5 },
+                    { "agent": "codex", "requests": 2 }
+                ]
+            }
+        })
+        .to_string();
+        let counts = parse_request_counts_by_agent(&body).unwrap();
+        assert_eq!(counts.get("claude-code"), Some(&5));
+        assert_eq!(counts.get("codex"), Some(&2));
+
+        // Proxy up, no traffic yet: empty map, not None.
+        let empty = json!({ "agent_usage": { "agents": [] } }).to_string();
+        assert!(parse_request_counts_by_agent(&empty).unwrap().is_empty());
+
+        // Unparseable body is None so the poller treats it as unreachable.
+        assert!(parse_request_counts_by_agent("not json").is_none());
+    }
+
     #[test]
     fn build_watchdog_give_up_report_uses_exit_status_when_present() {
         let report = build_watchdog_give_up_report(

src-tauri/src/client_adapters.rs

@@ -3508,6 +3508,7 @@ impl ToolManager {
     /// one host (Claude Code or Codex) still has the plugin registered, so a
     /// user who removes it via `/plugin` doesn't leave the card stuck on
     /// "Enabled".
+    #[cfg(test)]
     pub fn ponytail_installed(&self) -> bool {
         self.runtime.tools_dir.join("ponytail.json").exists()
             && PluginHost::ALL.iter().any(|host| host.plugin_present())

src-tauri/src/lib.rs

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Headroom",
-  "version": "0.4.6-rc.5",
+  "version": "0.4.6-rc.6",
   "identifier": "com.extraheadroom.headroom",
   "build": {
     "beforeDevCommand": "npm run dev",