From 52d3b55a324fa07ef3d59199fb058ae454605bdd Mon Sep 17 00:00:00 2001
From: Alejandro Blanco-M <alecuba16@gmail.com>
Date: Sat, 19 Sep 2026 09:29:28 +0200
Subject: [PATCH 01/21] Keep mermaid/math on halfblocks inside herdr-webui
 panes

herdr-webui's builtin backend exports TERM_PROGRAM=ghostty (with
KITTY_WINDOW_ID scrubbed) so inline read-tool images keep Kitty, but the
browser terminal cannot draw the Unicode-placeholder virtual placements
ratatui-image's Kitty path emits, so diagrams and math rendered as
garbage U+10EEEE glyphs. Gate protocol inference and the stdio probe on
HERDR_WEBUI: return None (Halfblocks default) and clamp probed native
protocols, restoring pre-merge text-art rendering. Standalone herdr
panes only export HERDR_ENV and keep pass-through behavior.
---
 .../jcode-tui-mermaid/src/mermaid_runtime.rs  | 82 ++++++++++++++++---
 1 file changed, 70 insertions(+), 12 deletions(-)

diff --git a/crates/jcode-tui-mermaid/src/mermaid_runtime.rs b/crates/jcode-tui-mermaid/src/mermaid_runtime.rs
index b8a1a381f2..cb0d367a5d 100644
--- a/crates/jcode-tui-mermaid/src/mermaid_runtime.rs
+++ b/crates/jcode-tui-mermaid/src/mermaid_runtime.rs
@@ -181,7 +181,21 @@ pub(super) fn infer_protocol_from_env(
     term_program: Option<&str>,
     lc_terminal: Option<&str>,
     kitty_window_id: Option<&str>,
+    herdr_webui: Option<&str>,
 ) -> Option<ProtocolType> {
+    // herdr-webui's browser terminal renders direct Kitty placements (inline
+    // read-tool images), but not the Unicode-placeholder virtual placements
+    // ratatui-image's Kitty path emits, so those placeholder cells would leak
+    // through as literal U+10EEEE glyphs. Its builtin backend exports
+    // HERDR_WEBUI=1 into every pane while advertising TERM_PROGRAM=ghostty
+    // (and scrubbing KITTY_WINDOW_ID) so inline images keep Kitty; that hint
+    // must not select a native protocol here. Returning None keeps the
+    // picker's Halfblocks default, so diagrams and math render as text art
+    // instead of garbage, matching any other graphics-less terminal.
+    if env_is_set(herdr_webui) {
+        return None;
+    }
+
     let term = term.unwrap_or("").to_ascii_lowercase();
     let term_program = term_program.unwrap_or("").to_ascii_lowercase();
     let lc_terminal = lc_terminal.unwrap_or("").to_ascii_lowercase();
@@ -293,6 +307,7 @@ fn fast_picker() -> Picker {
         std::env::var("TERM_PROGRAM").ok().as_deref(),
         std::env::var("LC_TERMINAL").ok().as_deref(),
         std::env::var("KITTY_WINDOW_ID").ok().as_deref(),
+        std::env::var("HERDR_WEBUI").ok().as_deref(),
     ) {
         picker.set_protocol_type(protocol);
     }
@@ -314,7 +329,21 @@ fn probe_picker() -> Picker {
     match Picker::from_query_stdio() {
         Ok(probed) => {
             let mut protocol = probed.protocol_type();
-            if protocol == ProtocolType::Iterm2 && real_iterm2_without_opt_in() {
+            if env_is_set(std::env::var("HERDR_WEBUI").ok().as_deref())
+                && matches!(
+                    protocol,
+                    ProtocolType::Kitty | ProtocolType::Iterm2 | ProtocolType::Sixel
+                )
+            {
+                // The builtin pane's Ghostty core answers the probe and claims
+                // Kitty, but the browser renderer cannot draw the Unicode
+                // placeholder cells that the Kitty protocol path emits; a probe
+                // answer must never unlock placements the webui cannot show.
+                crate::log_info(
+                    "Mermaid picker stdio probe detected a native protocol inside herdr-webui; falling back to halfblocks",
+                );
+                protocol = ProtocolType::Halfblocks;
+            } else if protocol == ProtocolType::Iterm2 && real_iterm2_without_opt_in() {
                 crate::log_info(
                     "Probe reported iTerm2 images, but iTerm2 image output is disabled;                      falling back to halfblocks",
                 );
@@ -370,6 +399,7 @@ pub fn init_picker() {
             std::env::var("TERM_PROGRAM").ok().as_deref(),
             std::env::var("LC_TERMINAL").ok().as_deref(),
             std::env::var("KITTY_WINDOW_ID").ok().as_deref(),
+            std::env::var("HERDR_WEBUI").ok().as_deref(),
         );
         let multiplexer = detect_multiplexer_from_env();
         let probe_override = std::env::var("JCODE_MERMAID_PICKER_PROBE")
@@ -740,20 +770,20 @@ mod tests {
     #[test]
     fn infer_protocol_detects_kitty_family() {
         assert_eq!(
-            infer_protocol_from_env(Some("xterm-kitty"), None, None, None),
+            infer_protocol_from_env(Some("xterm-kitty"), None, None, None, None),
             Some(ProtocolType::Kitty)
         );
         assert_eq!(
-            infer_protocol_from_env(None, Some("ghostty"), None, None),
+            infer_protocol_from_env(None, Some("ghostty"), None, None, None),
             Some(ProtocolType::Kitty)
         );
         assert_eq!(
-            infer_protocol_from_env(None, Some("HandTerm"), None, None),
+            infer_protocol_from_env(None, Some("HandTerm"), None, None, None),
             Some(ProtocolType::Kitty)
         );
         // KITTY_WINDOW_ID present is sufficient.
         assert_eq!(
-            infer_protocol_from_env(Some("xterm-256color"), None, None, Some("3")),
+            infer_protocol_from_env(Some("xterm-256color"), None, None, Some("3"), None),
             Some(ProtocolType::Kitty)
         );
     }
@@ -762,15 +792,15 @@ mod tests {
     fn infer_protocol_detects_iterm_and_sixel() {
         // Real iTerm2 breaks on inline images, so it reports no protocol.
         assert_eq!(
-            infer_protocol_from_env(None, Some("iTerm.app"), None, None),
+            infer_protocol_from_env(None, Some("iTerm.app"), None, None, None),
             None
         );
         assert_eq!(
-            infer_protocol_from_env(None, Some("WezTerm"), None, None),
+            infer_protocol_from_env(None, Some("WezTerm"), None, None, None),
             Some(ProtocolType::Iterm2)
         );
         assert_eq!(
-            infer_protocol_from_env(Some("xterm-sixel"), None, None, None),
+            infer_protocol_from_env(Some("xterm-sixel"), None, None, None, None),
             Some(ProtocolType::Sixel)
         );
     }
@@ -782,25 +812,53 @@ mod tests {
                 Some("xterm-kitty"),
                 Some("WezTerm"),
                 None,
-                Some("stale-kitty-window")
+                Some("stale-kitty-window"),
+                None
             ),
             Some(ProtocolType::Iterm2)
         );
         assert_eq!(
-            infer_protocol_from_env(Some("foot"), Some("foot"), None, None),
+            infer_protocol_from_env(Some("foot"), Some("foot"), None, None, None),
+            None
+        );
+        assert_eq!(
+            infer_protocol_from_env(Some("xterm-256color"), Some("konsole"), None, None, None),
+            None
+        );
+    }
+
+    #[test]
+    fn herdr_webui_overrides_kitty_hints_to_keep_halfblocks() {
+        // herdr-webui advertises a Ghostty-capable pane so inline read-tool
+        // images keep Kitty, but its browser renderer cannot draw the
+        // Unicode-placeholder virtual placements the mermaid viewport emits,
+        // so diagram/math rendering must stay on Halfblocks there.
+        assert_eq!(
+            infer_protocol_from_env(None, Some("ghostty"), None, None, Some("1")),
             None
         );
         assert_eq!(
-            infer_protocol_from_env(Some("xterm-256color"), Some("konsole"), None, None),
+            infer_protocol_from_env(Some("xterm-kitty"), None, None, Some("3"), Some("1")),
             None
         );
+        // Only the builtin webui backend exports HERDR_WEBUI; standalone herdr
+        // panes (HERDR_ENV) keep pass-through behavior untouched.
+        assert_eq!(
+            infer_protocol_from_env(None, Some("ghostty"), None, None, None),
+            Some(ProtocolType::Kitty)
+        );
+        // Empty value must not trigger the gate.
+        assert_eq!(
+            infer_protocol_from_env(None, Some("ghostty"), None, None, Some("")),
+            Some(ProtocolType::Kitty)
+        );
     }
 
     #[test]
     fn infer_protocol_misses_inside_masking_multiplexer() {
         // Herdr/tmux advertise a bland TERM with no graphics hints.
         assert_eq!(
-            infer_protocol_from_env(Some("xterm-256color"), None, None, None),
+            infer_protocol_from_env(Some("xterm-256color"), None, None, None, None),
             None
         );
     }

From 37c5c389bb5839a4c82225ebf74ebb5646cbdb4e Mon Sep 17 00:00:00 2001
From: Alejandro Blanco-M <alecuba16@gmail.com>
Date: Sat, 19 Sep 2026 09:33:33 +0200
Subject: [PATCH 02/21] Add process-level HERDR_WEBUI protocol gate regression
 test

Spawns the test binary as a child carrying the exact env the builtin
webui backend exports (HERDR_WEBUI=1, TERM_PROGRAM=ghostty,
KITTY_WINDOW_ID scrubbed) and asserts the picker stays on Halfblocks,
with a control child (HERDR_WEBUI scrubbed) proving the same ghostty
hint selects Kitty without the gate.
---
 .../tests/webui_protocol_gate.rs              | 89 +++++++++++++++++++
 1 file changed, 89 insertions(+)
 create mode 100644 crates/jcode-tui-mermaid/tests/webui_protocol_gate.rs

diff --git a/crates/jcode-tui-mermaid/tests/webui_protocol_gate.rs b/crates/jcode-tui-mermaid/tests/webui_protocol_gate.rs
new file mode 100644
index 0000000000..afad23c008
--- /dev/null
+++ b/crates/jcode-tui-mermaid/tests/webui_protocol_gate.rs
@@ -0,0 +1,89 @@
+//! Process-level regression test for the HERDR_WEBUI mermaid/math protocol
+//! gate (branch `herdr_webui_halfblocks`).
+//!
+//! The global PICKER is a process-global OnceLock, so env-based protocol
+//! inference can only be exercised faithfully by initializing it in a fresh
+//! process carrying the exact environment herdr-webui's builtin backend
+//! exports into panes: HERDR_WEBUI=1, TERM_PROGRAM=ghostty, the pane's TERM,
+//! and KITTY_WINDOW_ID scrubbed (webui src/builtin_backend.rs). The parent
+//! spawns itself as a child with that environment; the child calls
+//! init_picker() and asserts the picker stays on Halfblocks (halfblock
+//! text art the browser can actually draw) instead of Kitty, whose
+//! unicode-placeholder placements leak through as U+10EEEE garbage.
+//!
+//! A control child with the identical environment minus HERDR_WEBUI proves
+//! the same TERM_PROGRAM=ghostty hint selects Kitty without the gate, so the
+//! assertion exercises the gate itself rather than an accident of the
+//! environment. Both children pin JCODE_MERMAID_PICKER_PROBE off and scrub
+//! KITTY_WINDOW_ID/LC_TERMINAL/HERDR_WEBUI so the outcome is deterministic
+//! no matter where the suite runs (including inside a webui pane).
+
+use std::process::{Command, Output};
+
+const CHILD_MODE_VAR: &str = "JCODE_TEST_WEBUI_GATE_CHILD";
+const TEST_NAME: &str = "herdr_webui_gate_picks_halfblocks_and_control_picks_kitty";
+
+fn spawn_gate_child(mode: &'static str) -> Output {
+    let exe = std::env::current_exe().expect("test binary path");
+    let mut command = Command::new(exe);
+    command
+        .arg("--exact")
+        .arg(TEST_NAME)
+        .arg("--nocapture")
+        .env(CHILD_MODE_VAR, mode)
+        // Pin the exact pane environment the builtin webui backend exports.
+        .env("TERM", "xterm-256color")
+        .env("TERM_PROGRAM", "ghostty")
+        .env_remove("KITTY_WINDOW_ID")
+        .env_remove("LC_TERMINAL")
+        // The probe is opt-in and queries stdio, which is piped here; pin the
+        // default Fast init mode so the child is deterministic.
+        .env_remove("JCODE_MERMAID_PICKER_PROBE");
+    match mode {
+        "webui" => {
+            command.env("HERDR_WEBUI", "1");
+        }
+        "control" => {
+            command.env_remove("HERDR_WEBUI");
+        }
+        other => panic!("unknown gate child mode: {other}"),
+    }
+    command.output().expect("spawn HERDR_WEBUI gate child")
+}
+
+fn require_gate_child(mode: &'static str, expected: &str) {
+    let output = spawn_gate_child(mode);
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    assert!(
+        output.status.success(),
+        "{mode} child failed with {:?}\nstdout:\n{stdout}\nstderr:\n{stderr}",
+        output.status.code()
+    );
+    let marker = format!("GATE_RESULT={expected}");
+    assert!(
+        stdout.contains(&marker),
+        "{mode} child did not report {marker}\nstdout:\n{stdout}"
+    );
+}
+
+#[test]
+fn herdr_webui_gate_picks_halfblocks_and_control_picks_kitty() {
+    // Child mode: initialize the picker under the inherited environment and
+    // report the resulting protocol; the parent asserts on the marker.
+    if let Ok(mode) = std::env::var(CHILD_MODE_VAR) {
+        let expected = match mode.as_str() {
+            "webui" => "Some(Halfblocks)",
+            "control" => "Some(Kitty)",
+            other => panic!("unknown gate child mode: {other}"),
+        };
+        jcode_tui_mermaid::init_picker();
+        let actual = format!("{:?}", jcode_tui_mermaid::protocol_type());
+        println!("GATE_RESULT={actual}");
+        assert_eq!(actual, expected, "{mode} child protocol mismatch");
+        return;
+    }
+
+    require_gate_child("webui", "Some(Halfblocks)");
+    require_gate_child("control", "Some(Kitty)");
+}
\ No newline at end of file

From c261a73e2831bcce1cfea30f852edfad4db787d1 Mon Sep 17 00:00:00 2001
From: Alejandro Blanco-M <alecuba16@gmail.com>
Date: Sat, 19 Sep 2026 10:42:21 +0200
Subject: [PATCH 03/21] Fix pre-existing clippy 1.96 lint debt across workspace

Upstream merge 66ddaf2d2 carried lint violations under the newer
clippy (is_multiple_of, let-chain collapsible-if, while-let loop,
items-after-test-module, needless returns, type complexity,
double-ended iterator last, unnecessary sort_by, bool simplification,
from_ref). CI runs clippy --workspace --all-targets --all-features
-D warnings, so the branch could not pass.

Mechanical fixes keep semantics identical. Judgment calls:
- goal.rs InitiativeTool stays with #![allow(dead_code)] per the
  upstream keep-intact comment in tool/mod.rs (tool is temporarily
  unregistered but kept restorable without a migration)
- copy_to_clipboard_osc52 and telemetry delivery machinery get
  cfg_attr(test, allow(dead_code)): only wired through cfg(not(test))
  paths, tests stub them
- test env guards held across async bodies get await_holding_lock
  allows matching the existing repo convention
- setup-hints cfg(any(test, linux)) narrowed to linux where no test
  uses the items
- misplaced #[expect(too_many_arguments)] in comm_session.rs moved to
  spawn_swarm_agent where the 21-arg signature lives

cargo clippy --workspace --all-targets --all-features -- -D
warnings: clean. cargo fmt --check: clean.
---
 crates/jcode-app-core/src/agent_tests.rs      |  17 +-
 crates/jcode-app-core/src/network_retry.rs    |   4 +-
 .../src/server/background_tasks.rs            |  70 ++--
 .../src/server/client_lifecycle.rs            |   6 +-
 .../src/server/client_lifecycle_tests.rs      |   1 +
 .../jcode-app-core/src/server/comm_session.rs |   8 +-
 .../src/server/debug_command_exec.rs          |   2 +-
 .../src/server/debug_server_state.rs          | 208 +++++------
 .../src/server/provider_control_tests.rs      |   2 +-
 crates/jcode-app-core/src/tool/apply_patch.rs |   2 +-
 .../jcode-app-core/src/tool/browser_fast.rs   |  20 +-
 .../jcode-app-core/src/tool/browser_tests.rs  |   2 +
 .../src/tool/computer/coverage_tests.rs       |   8 +-
 .../jcode-app-core/src/tool/computer/mod.rs   |   2 +-
 .../src/tool/config_edit_notice_tests.rs      |   2 +
 crates/jcode-app-core/src/tool/discover.rs    |   1 +
 crates/jcode-app-core/src/tool/goal.rs        |   4 +
 crates/jcode-app-core/src/tool/memory.rs      |   1 +
 crates/jcode-app-core/src/tool/open.rs        |   4 +-
 crates/jcode-app-core/src/tool/patch.rs       |   2 +-
 crates/jcode-app-core/src/tool/todo.rs        |   3 +-
 .../src/turn_cancel_registry.rs               |  32 +-
 crates/jcode-app-core/src/update.rs           |   6 +-
 crates/jcode-base/src/account_login/tests.rs  |   2 +
 crates/jcode-base/src/auth/cursor.rs          |   4 +-
 crates/jcode-base/src/auth/lifecycle.rs       |   5 +-
 crates/jcode-base/src/mcp/pool.rs             |   1 +
 crates/jcode-base/src/model_usage.rs          |   3 +-
 crates/jcode-base/src/todo.rs                 |  12 +-
 .../src/storage_helpers.rs                    |  84 ++---
 crates/jcode-core/src/stdin_detect.rs         |   4 +-
 crates/jcode-core/src/stdin_detect_tests.rs   |   1 +
 crates/jcode-harness-api-server/src/lib.rs    |   4 +
 .../jcode-harness-api-server/src/translate.rs |  16 +-
 .../src/translate_tests.rs                    |  33 +-
 crates/jcode-harness-api/src/edit_stats.rs    |  15 +-
 .../harness_api_tests/capability_coverage.rs  |   9 +-
 .../src/harness_api_tests/schema_snapshot.rs  |   8 +-
 crates/jcode-message-types/src/lib.rs         |   4 +-
 crates/jcode-protocol/src/wire.rs             |   4 +-
 crates/jcode-provider-metadata/src/lib.rs     |  12 +-
 .../src/openai_tests/persistent_terminal.rs   |   5 +
 .../src/openai_tests/websocket_prewarm.rs     |   7 +
 .../src/openai_usage_recording.rs             |   1 +
 .../src/openrouter_catalog_merge_tests.rs     |   1 +
 crates/jcode-sdk/src/auth.rs                  |   8 +-
 crates/jcode-sdk/src/client.rs                |  24 +-
 crates/jcode-sdk/src/launch.rs                |  12 +-
 crates/jcode-sdk/src/ssh.rs                   |  34 +-
 crates/jcode-sdk/src/structured.rs            |   2 +-
 crates/jcode-sdk/tests/client_behavior.rs     |   7 +-
 crates/jcode-setup-hints/src/lib.rs           |  18 +-
 crates/jcode-setup-hints/src/linux_env.rs     |   4 +-
 crates/jcode-telemetry-core/src/lib.rs        |  23 +-
 crates/jcode-terminal-launch/src/lib.rs       |   4 +-
 crates/jcode-transport/src/unix.rs            |   2 +-
 crates/jcode-tui-markdown/src/lib.rs          |   3 +-
 crates/jcode-tui-mermaid/src/lib.rs           |   4 +-
 .../jcode-tui-mermaid/src/mermaid_content.rs  | 150 ++++----
 .../src/mermaid_tests/part_02.rs              |   3 +-
 .../jcode-tui-mermaid/src/mermaid_viewport.rs |   2 +-
 .../tests/webui_protocol_gate.rs              |   2 +-
 crates/jcode-tui-style/src/theme_mode.rs      |   8 +-
 .../app/auth_account_picker_saved_accounts.rs |  50 +--
 crates/jcode-tui/src/tui/app/auth_remote.rs   |  16 +-
 .../src/tui/app/auth_remote/onboarding.rs     | 324 +++++++++---------
 crates/jcode-tui/src/tui/app/helpers.rs       |  21 +-
 .../src/tui/app/remote/server_events.rs       |   6 +-
 .../jcode-tui/src/tui/app/tests/ssh_remote.rs |   8 +-
 crates/jcode-tui/src/tui/backend.rs           |   6 +-
 .../src/tui/session_picker/loading_tests.rs   |   9 +-
 crates/jcode-tui/src/tui/ui_messages.rs       |   6 +-
 .../src/tui/ui_tests/palette_topology.rs      |   8 +-
 src/cli/acp.rs                                |   7 +-
 src/cli/commands/menubar.rs                   |  11 +-
 src/cli/commands_tests.rs                     |   5 +
 src/cli/login/scriptable.rs                   |   3 +
 src/cli/login/tests.rs                        |   1 +
 src/cli/macos_notification_broker.rs          |   4 +-
 79 files changed, 778 insertions(+), 659 deletions(-)

diff --git a/crates/jcode-app-core/src/agent_tests.rs b/crates/jcode-app-core/src/agent_tests.rs
index d258d14ead..ccb71521ae 100644
--- a/crates/jcode-app-core/src/agent_tests.rs
+++ b/crates/jcode-app-core/src/agent_tests.rs
@@ -1782,12 +1782,17 @@ fn empty_post_tool_response_gets_more_than_one_retry() {
     // transient hiccup, not a finished task. With only one retry allowed, a
     // single empty response (observed once in 43 turns) ended a 20-hour agent
     // run with the work half-done and the submission unoptimized.
-    assert!(
-        Agent::MAX_EMPTY_POST_TOOL_CONTINUATION_ATTEMPTS > 1,
-        "a single retry lets one transient empty response end a long run"
-    );
-    // Bounded, so a genuinely finished agent still exits instead of looping.
-    assert!(Agent::MAX_EMPTY_POST_TOOL_CONTINUATION_ATTEMPTS <= 10);
+    // assertions_on_constants fires because both bounds are compile-known; the
+    // guard is kept as a readable regression test, not dead code.
+    #[allow(clippy::assertions_on_constants)]
+    {
+        assert!(
+            Agent::MAX_EMPTY_POST_TOOL_CONTINUATION_ATTEMPTS > 1,
+            "a single retry lets one transient empty response end a long run"
+        );
+        // Bounded, so a genuinely finished agent still exits instead of looping.
+        assert!(Agent::MAX_EMPTY_POST_TOOL_CONTINUATION_ATTEMPTS <= 10);
+    }
 }
 
 #[test]
diff --git a/crates/jcode-app-core/src/network_retry.rs b/crates/jcode-app-core/src/network_retry.rs
index 3c19ced1bf..5636d86950 100644
--- a/crates/jcode-app-core/src/network_retry.rs
+++ b/crates/jcode-app-core/src/network_retry.rs
@@ -81,12 +81,12 @@ pub fn wait_plan() -> NetworkWaitPlan {
     }
     #[cfg(target_os = "macos")]
     {
-        return NetworkWaitPlan {
+        NetworkWaitPlan {
             reason: "stream interrupted by a likely network disconnect".to_string(),
             listener_summary:
                 "listening for macOS route/interface changes via `route -n monitor`; also verifying with reconnect probes"
                     .to_string(),
-        };
+        }
     }
     #[cfg(not(any(target_os = "linux", target_os = "macos")))]
     {
diff --git a/crates/jcode-app-core/src/server/background_tasks.rs b/crates/jcode-app-core/src/server/background_tasks.rs
index a294192e71..6151c98c05 100644
--- a/crates/jcode-app-core/src/server/background_tasks.rs
+++ b/crates/jcode-app-core/src/server/background_tasks.rs
@@ -583,6 +583,41 @@ fn cap_chars(s: &str, cap: usize) -> String {
     out
 }
 
+pub(super) async fn dispatch_ui_activity(
+    activity: &crate::bus::UiActivity,
+    swarm_members: &Arc<RwLock<HashMap<String, SwarmMember>>>,
+) {
+    if activity.message.trim().is_empty() {
+        return;
+    }
+    let Some(session_id) = activity.session_id.as_deref() else {
+        return;
+    };
+
+    if fanout_session_event(
+        swarm_members,
+        session_id,
+        ServerEvent::Notification {
+            from_session: "jcode".to_string(),
+            from_name: Some("Jcode".to_string()),
+            notification_type: NotificationType::Message {
+                scope: Some(activity.kind.scope().to_string()),
+                channel: None,
+                tldr: None,
+            },
+            message: activity.message.clone(),
+        },
+    )
+    .await
+        == 0
+    {
+        crate::logging::warn(&format!(
+            "Failed to notify attached clients for UI activity on session {}",
+            session_id
+        ));
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -673,38 +708,3 @@ mod tests {
         assert!(!update_active_todo_batch_progress(&mut items, &progress));
     }
 }
-
-pub(super) async fn dispatch_ui_activity(
-    activity: &crate::bus::UiActivity,
-    swarm_members: &Arc<RwLock<HashMap<String, SwarmMember>>>,
-) {
-    if activity.message.trim().is_empty() {
-        return;
-    }
-    let Some(session_id) = activity.session_id.as_deref() else {
-        return;
-    };
-
-    if fanout_session_event(
-        swarm_members,
-        session_id,
-        ServerEvent::Notification {
-            from_session: "jcode".to_string(),
-            from_name: Some("Jcode".to_string()),
-            notification_type: NotificationType::Message {
-                scope: Some(activity.kind.scope().to_string()),
-                channel: None,
-                tldr: None,
-            },
-            message: activity.message.clone(),
-        },
-    )
-    .await
-        == 0
-    {
-        crate::logging::warn(&format!(
-            "Failed to notify attached clients for UI activity on session {}",
-            session_id
-        ));
-    }
-}
diff --git a/crates/jcode-app-core/src/server/client_lifecycle.rs b/crates/jcode-app-core/src/server/client_lifecycle.rs
index 318d0e300b..b3b2908f02 100644
--- a/crates/jcode-app-core/src/server/client_lifecycle.rs
+++ b/crates/jcode-app-core/src/server/client_lifecycle.rs
@@ -1297,10 +1297,8 @@ pub(super) async fn handle_client(
                         active_turn_registered,
                         session_connection_busy,
                     );
-                    if start {
-                        if let Some(info) = connections.get_mut(&client_connection_id) {
-                            info.is_processing = true;
-                        }
+                    if start && let Some(info) = connections.get_mut(&client_connection_id) {
+                        info.is_processing = true;
                     }
                     start
                 };
diff --git a/crates/jcode-app-core/src/server/client_lifecycle_tests.rs b/crates/jcode-app-core/src/server/client_lifecycle_tests.rs
index 59e6273ddb..cd421296c4 100644
--- a/crates/jcode-app-core/src/server/client_lifecycle_tests.rs
+++ b/crates/jcode-app-core/src/server/client_lifecycle_tests.rs
@@ -1,3 +1,4 @@
+#![allow(clippy::await_holding_lock)] // env guards held across async test bodies
 use super::*;
 use crate::message::{ContentBlock, Message, StreamEvent, ToolDefinition};
 use crate::provider::{EventStream, Provider};
diff --git a/crates/jcode-app-core/src/server/comm_session.rs b/crates/jcode-app-core/src/server/comm_session.rs
index 7ffd473c2e..a02312b586 100644
--- a/crates/jcode-app-core/src/server/comm_session.rs
+++ b/crates/jcode-app-core/src/server/comm_session.rs
@@ -549,10 +549,6 @@ async fn register_visible_spawned_member(
     broadcast_swarm_status(swarm_id, swarm_members, swarms_by_id).await;
 }
 
-#[expect(
-    clippy::too_many_arguments,
-    reason = "server-side swarm spawning needs session, swarm state, provider, and event sinks together"
-)]
 /// Resolve the reasoning effort for a spawned swarm worker (#1165).
 ///
 /// Precedence mirrors the model path: an explicit `effort` on the spawn call
@@ -571,6 +567,10 @@ pub(super) fn resolve_swarm_spawn_effort(
     clean(requested_effort).or_else(|| clean(configured_swarm_effort))
 }
 
+#[expect(
+    clippy::too_many_arguments,
+    reason = "server-side swarm spawning needs session, swarm state, provider, and event sinks together"
+)]
 pub(super) async fn spawn_swarm_agent(
     req_session_id: &str,
     swarm_id: &str,
diff --git a/crates/jcode-app-core/src/server/debug_command_exec.rs b/crates/jcode-app-core/src/server/debug_command_exec.rs
index 34b2c7ae36..e063148971 100644
--- a/crates/jcode-app-core/src/server/debug_command_exec.rs
+++ b/crates/jcode-app-core/src/server/debug_command_exec.rs
@@ -653,7 +653,7 @@ mod tests {
     use jcode_agent_runtime::InterruptSignal;
     use std::collections::HashMap;
     use std::ffi::OsString;
-    use std::sync::{Arc, Mutex, OnceLock};
+    use std::sync::Arc;
     use std::time::{Duration, Instant};
     use tokio::sync::{Mutex as AsyncMutex, RwLock};
 
diff --git a/crates/jcode-app-core/src/server/debug_server_state.rs b/crates/jcode-app-core/src/server/debug_server_state.rs
index e582e08261..fca9a4151b 100644
--- a/crates/jcode-app-core/src/server/debug_server_state.rs
+++ b/crates/jcode-app-core/src/server/debug_server_state.rs
@@ -646,110 +646,6 @@ async fn build_server_memory_incident_payload(
     })
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::time::Duration;
-
-    #[tokio::test]
-    async fn connected_session_snapshot_releases_connections_before_waiting_for_sessions() {
-        let sessions = Arc::new(RwLock::new(HashMap::new()));
-        let client_connections = Arc::new(RwLock::new(HashMap::new()));
-        let swarm_members = Arc::new(RwLock::new(HashMap::new()));
-
-        let sessions_gate = sessions.write().await;
-        let snapshot = connected_session_snapshot(&sessions, &client_connections, &swarm_members);
-        tokio::pin!(snapshot);
-        tokio::select! {
-            _ = &mut snapshot => panic!("snapshot unexpectedly completed"),
-            _ = tokio::time::sleep(Duration::from_millis(20)) => {}
-        }
-
-        let connections_guard =
-            tokio::time::timeout(Duration::from_millis(100), client_connections.write())
-                .await
-                .expect("debug snapshot retained connections while waiting for sessions");
-        drop(connections_guard);
-
-        drop(sessions_gate);
-        let (connected_agents, members) =
-            tokio::time::timeout(Duration::from_secs(1), &mut snapshot)
-                .await
-                .expect("debug snapshot deadlocked");
-        assert!(connected_agents.is_empty());
-        assert!(members.is_empty());
-    }
-
-    #[test]
-    fn spawned_swarm_agent_count_only_includes_live_owned_sessions() {
-        let live_session_ids = HashSet::from([
-            "root".to_string(),
-            "worker-running".to_string(),
-            "worker-ready".to_string(),
-        ]);
-        let spawned_session_ids = [
-            "worker-running".to_string(),
-            "worker-ready".to_string(),
-            "worker-stale".to_string(),
-        ];
-
-        assert_eq!(
-            count_live_spawned_swarm_agents(&live_session_ids, spawned_session_ids.iter()),
-            2
-        );
-    }
-
-    #[test]
-    fn memory_incident_classifies_runaway_live_sessions_before_allocator_retention() {
-        let decision = classify_memory_incident(MemoryIncidentMetrics {
-            pss_bytes: 4 * 1024 * 1024 * 1024,
-            pss_growth_bytes: 3 * 1024 * 1024 * 1024,
-            allocator_live_bytes: 3_800 * 1024 * 1024,
-            allocator_retained_resident_bytes: 300 * 1024 * 1024,
-            live_sessions: 1_145,
-            headless_live_sessions: 1_140,
-            connected_clients: 5,
-        });
-
-        assert_eq!(decision.severity, "critical");
-        assert_eq!(decision.primary_cause, "runaway_live_session_population");
-        assert_eq!(decision.confidence, "high");
-    }
-
-    #[test]
-    fn memory_incident_classifies_allocator_retention_when_live_heap_is_small() {
-        let decision = classify_memory_incident(MemoryIncidentMetrics {
-            pss_bytes: 1_500 * 1024 * 1024,
-            pss_growth_bytes: 400 * 1024 * 1024,
-            allocator_live_bytes: 500 * 1024 * 1024,
-            allocator_retained_resident_bytes: 600 * 1024 * 1024,
-            live_sessions: 8,
-            headless_live_sessions: 3,
-            connected_clients: 5,
-        });
-
-        assert_eq!(decision.severity, "warning");
-        assert_eq!(decision.primary_cause, "allocator_retention");
-        assert_eq!(decision.confidence, "high");
-    }
-
-    #[test]
-    fn memory_incident_reports_healthy_baseline() {
-        let decision = classify_memory_incident(MemoryIncidentMetrics {
-            pss_bytes: 220 * 1024 * 1024,
-            pss_growth_bytes: 12 * 1024 * 1024,
-            allocator_live_bytes: 150 * 1024 * 1024,
-            allocator_retained_resident_bytes: 20 * 1024 * 1024,
-            live_sessions: 5,
-            headless_live_sessions: 1,
-            connected_clients: 4,
-        });
-
-        assert_eq!(decision.severity, "healthy");
-        assert_eq!(decision.primary_cause, "within_normal_operating_range");
-    }
-}
-
 #[expect(
     clippy::too_many_arguments,
     reason = "server memory payload aggregates many live server structures into one debug snapshot"
@@ -1255,3 +1151,107 @@ fn estimate_swarm_event_bytes(event: &SwarmEvent) -> usize {
 fn path_len(path: &std::path::Path) -> usize {
     path.to_string_lossy().len()
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::time::Duration;
+
+    #[tokio::test]
+    async fn connected_session_snapshot_releases_connections_before_waiting_for_sessions() {
+        let sessions = Arc::new(RwLock::new(HashMap::new()));
+        let client_connections = Arc::new(RwLock::new(HashMap::new()));
+        let swarm_members = Arc::new(RwLock::new(HashMap::new()));
+
+        let sessions_gate = sessions.write().await;
+        let snapshot = connected_session_snapshot(&sessions, &client_connections, &swarm_members);
+        tokio::pin!(snapshot);
+        tokio::select! {
+            _ = &mut snapshot => panic!("snapshot unexpectedly completed"),
+            _ = tokio::time::sleep(Duration::from_millis(20)) => {}
+        }
+
+        let connections_guard =
+            tokio::time::timeout(Duration::from_millis(100), client_connections.write())
+                .await
+                .expect("debug snapshot retained connections while waiting for sessions");
+        drop(connections_guard);
+
+        drop(sessions_gate);
+        let (connected_agents, members) =
+            tokio::time::timeout(Duration::from_secs(1), &mut snapshot)
+                .await
+                .expect("debug snapshot deadlocked");
+        assert!(connected_agents.is_empty());
+        assert!(members.is_empty());
+    }
+
+    #[test]
+    fn spawned_swarm_agent_count_only_includes_live_owned_sessions() {
+        let live_session_ids = HashSet::from([
+            "root".to_string(),
+            "worker-running".to_string(),
+            "worker-ready".to_string(),
+        ]);
+        let spawned_session_ids = [
+            "worker-running".to_string(),
+            "worker-ready".to_string(),
+            "worker-stale".to_string(),
+        ];
+
+        assert_eq!(
+            count_live_spawned_swarm_agents(&live_session_ids, spawned_session_ids.iter()),
+            2
+        );
+    }
+
+    #[test]
+    fn memory_incident_classifies_runaway_live_sessions_before_allocator_retention() {
+        let decision = classify_memory_incident(MemoryIncidentMetrics {
+            pss_bytes: 4 * 1024 * 1024 * 1024,
+            pss_growth_bytes: 3 * 1024 * 1024 * 1024,
+            allocator_live_bytes: 3_800 * 1024 * 1024,
+            allocator_retained_resident_bytes: 300 * 1024 * 1024,
+            live_sessions: 1_145,
+            headless_live_sessions: 1_140,
+            connected_clients: 5,
+        });
+
+        assert_eq!(decision.severity, "critical");
+        assert_eq!(decision.primary_cause, "runaway_live_session_population");
+        assert_eq!(decision.confidence, "high");
+    }
+
+    #[test]
+    fn memory_incident_classifies_allocator_retention_when_live_heap_is_small() {
+        let decision = classify_memory_incident(MemoryIncidentMetrics {
+            pss_bytes: 1_500 * 1024 * 1024,
+            pss_growth_bytes: 400 * 1024 * 1024,
+            allocator_live_bytes: 500 * 1024 * 1024,
+            allocator_retained_resident_bytes: 600 * 1024 * 1024,
+            live_sessions: 8,
+            headless_live_sessions: 3,
+            connected_clients: 5,
+        });
+
+        assert_eq!(decision.severity, "warning");
+        assert_eq!(decision.primary_cause, "allocator_retention");
+        assert_eq!(decision.confidence, "high");
+    }
+
+    #[test]
+    fn memory_incident_reports_healthy_baseline() {
+        let decision = classify_memory_incident(MemoryIncidentMetrics {
+            pss_bytes: 220 * 1024 * 1024,
+            pss_growth_bytes: 12 * 1024 * 1024,
+            allocator_live_bytes: 150 * 1024 * 1024,
+            allocator_retained_resident_bytes: 20 * 1024 * 1024,
+            live_sessions: 5,
+            headless_live_sessions: 1,
+            connected_clients: 4,
+        });
+
+        assert_eq!(decision.severity, "healthy");
+        assert_eq!(decision.primary_cause, "within_normal_operating_range");
+    }
+}
diff --git a/crates/jcode-app-core/src/server/provider_control_tests.rs b/crates/jcode-app-core/src/server/provider_control_tests.rs
index 98e93ea999..2ed1e76805 100644
--- a/crates/jcode-app-core/src/server/provider_control_tests.rs
+++ b/crates/jcode-app-core/src/server/provider_control_tests.rs
@@ -7,7 +7,7 @@ use std::collections::HashMap;
 use std::pin::Pin;
 use std::sync::RwLock as StdRwLock;
 use std::sync::atomic::{AtomicUsize, Ordering};
-use std::sync::{Mutex as StdMutex, MutexGuard as StdMutexGuard, OnceLock};
+use std::sync::{Mutex as StdMutex, MutexGuard as StdMutexGuard};
 
 async fn recv_final_catalog_notification(rx: &mut mpsc::UnboundedReceiver<ServerEvent>) -> String {
     tokio::time::timeout(std::time::Duration::from_secs(2), async {
diff --git a/crates/jcode-app-core/src/tool/apply_patch.rs b/crates/jcode-app-core/src/tool/apply_patch.rs
index a9f129dc7f..100b3fdc35 100644
--- a/crates/jcode-app-core/src/tool/apply_patch.rs
+++ b/crates/jcode-app-core/src/tool/apply_patch.rs
@@ -143,7 +143,7 @@ impl Tool for ApplyPatchTool {
                     let old_contents = old.as_deref().unwrap_or("");
                     if tokio::fs::remove_file(&resolved).await.is_ok() {
                         super::edit_stats::record(&ctx, old_contents, "", old.is_none()).await;
-                        let diff = generate_diff_summary(&old_contents, "");
+                        let diff = generate_diff_summary(old_contents, "");
                         publish_file_touch(
                             &ctx,
                             &resolved,
diff --git a/crates/jcode-app-core/src/tool/browser_fast.rs b/crates/jcode-app-core/src/tool/browser_fast.rs
index d88b34291c..1db6d75a64 100644
--- a/crates/jcode-app-core/src/tool/browser_fast.rs
+++ b/crates/jcode-app-core/src/tool/browser_fast.rs
@@ -112,12 +112,20 @@ fn redact_credentials(value: &mut Value) -> bool {
             *text = "[REDACTED: credential material]".into();
             true
         }
-        Value::Array(items) => items
-            .iter_mut()
-            .fold(false, |found, item| redact_credentials(item) || found),
-        Value::Object(items) => items
-            .values_mut()
-            .fold(false, |found, item| redact_credentials(item) || found),
+        Value::Array(items) => {
+            let mut found = false;
+            for item in items {
+                found |= redact_credentials(item);
+            }
+            found
+        }
+        Value::Object(items) => {
+            let mut found = false;
+            for item in items.values_mut() {
+                found |= redact_credentials(item);
+            }
+            found
+        }
         _ => false,
     }
 }
diff --git a/crates/jcode-app-core/src/tool/browser_tests.rs b/crates/jcode-app-core/src/tool/browser_tests.rs
index 6d66c3ac2a..fde08b1fbd 100644
--- a/crates/jcode-app-core/src/tool/browser_tests.rs
+++ b/crates/jcode-app-core/src/tool/browser_tests.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::await_holding_lock)] // env guards held across async test bodies
+
 use super::*;
 
 #[test]
diff --git a/crates/jcode-app-core/src/tool/computer/coverage_tests.rs b/crates/jcode-app-core/src/tool/computer/coverage_tests.rs
index f049e1562a..de9599c96e 100644
--- a/crates/jcode-app-core/src/tool/computer/coverage_tests.rs
+++ b/crates/jcode-app-core/src/tool/computer/coverage_tests.rs
@@ -184,10 +184,10 @@ fn first_window_id_for(text: &str, owner: &str) -> Option<i64> {
         let mut parts = line.splitn(4, '\t');
         let id = parts.next()?.trim();
         let own = parts.next().unwrap_or("").trim();
-        if own == owner {
-            if let Ok(n) = id.parse::<i64>() {
-                return Some(n);
-            }
+        if own == owner
+            && let Ok(n) = id.parse::<i64>()
+        {
+            return Some(n);
         }
     }
     None
diff --git a/crates/jcode-app-core/src/tool/computer/mod.rs b/crates/jcode-app-core/src/tool/computer/mod.rs
index 409a62661c..9b1f4f0901 100644
--- a/crates/jcode-app-core/src/tool/computer/mod.rs
+++ b/crates/jcode-app-core/src/tool/computer/mod.rs
@@ -507,7 +507,7 @@ fn require_xy(input: &ComputerInput) -> Result<(f64, f64)> {
 }
 
 #[cfg(target_os = "macos")]
-fn req_app<'a>(input: &'a ComputerInput) -> Result<&'a str> {
+fn req_app(input: &ComputerInput) -> Result<&str> {
     input
         .app
         .as_deref()
diff --git a/crates/jcode-app-core/src/tool/config_edit_notice_tests.rs b/crates/jcode-app-core/src/tool/config_edit_notice_tests.rs
index 7ab7f51729..eeb41845f3 100644
--- a/crates/jcode-app-core/src/tool/config_edit_notice_tests.rs
+++ b/crates/jcode-app-core/src/tool/config_edit_notice_tests.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::await_holding_lock)] // env guards held across async test bodies
+
 use super::*;
 
 /// Point the process at a temp jcode home and return it with a restore guard.
diff --git a/crates/jcode-app-core/src/tool/discover.rs b/crates/jcode-app-core/src/tool/discover.rs
index 1847f74f17..258cf52ddd 100644
--- a/crates/jcode-app-core/src/tool/discover.rs
+++ b/crates/jcode-app-core/src/tool/discover.rs
@@ -1,3 +1,4 @@
+#![cfg_attr(test, allow(clippy::await_holding_lock))] // env guards held across async test bodies
 use super::discover_secrets::contains_recognizable_secret;
 use super::{Tool, ToolContext, ToolExecutionMode, ToolOutput};
 use anyhow::Result;
diff --git a/crates/jcode-app-core/src/tool/goal.rs b/crates/jcode-app-core/src/tool/goal.rs
index 0e0e99db15..aec6310ae8 100644
--- a/crates/jcode-app-core/src/tool/goal.rs
+++ b/crates/jcode-app-core/src/tool/goal.rs
@@ -1,3 +1,7 @@
+// Initiative is temporarily unregistered (see the matching comment in
+// mod.rs); the implementation is kept intact so it can be restored without
+// a migration, so the registration gap must not fail the dead_code lint.
+#![allow(dead_code)]
 #![cfg_attr(test, allow(clippy::await_holding_lock))]
 
 use super::{Tool, ToolContext, ToolOutput};
diff --git a/crates/jcode-app-core/src/tool/memory.rs b/crates/jcode-app-core/src/tool/memory.rs
index 0123450370..7fcd8fb18d 100644
--- a/crates/jcode-app-core/src/tool/memory.rs
+++ b/crates/jcode-app-core/src/tool/memory.rs
@@ -1,5 +1,6 @@
 //! Memory tool for storing and recalling information across sessions
 
+#![cfg_attr(test, allow(clippy::await_holding_lock))] // env guards held across async test bodies
 use super::{Tool, ToolContext, ToolOutput};
 use crate::memory::{MemoryCategory, MemoryEntry, MemoryManager, MemoryScope};
 use anyhow::Result;
diff --git a/crates/jcode-app-core/src/tool/open.rs b/crates/jcode-app-core/src/tool/open.rs
index 23def9adc8..b8e9d2f623 100644
--- a/crates/jcode-app-core/src/tool/open.rs
+++ b/crates/jcode-app-core/src/tool/open.rs
@@ -363,7 +363,7 @@ async fn open_target(target: &ResolvedTarget) -> Result<String> {
             }
         }
         spawn_with_grace(cmd, "open").await?;
-        return Ok("open".to_string());
+        Ok("open".to_string())
     }
 
     #[cfg(all(unix, not(target_os = "macos")))]
@@ -403,7 +403,7 @@ async fn reveal_target(path: &Path, kind: LocalTargetKind) -> Result<(String, bo
             cmd.arg("-R").arg(path);
         }
         spawn_with_grace(cmd, "open").await?;
-        return Ok(("open".to_string(), true));
+        Ok(("open".to_string(), true))
     }
 
     #[cfg(all(unix, not(target_os = "macos")))]
diff --git a/crates/jcode-app-core/src/tool/patch.rs b/crates/jcode-app-core/src/tool/patch.rs
index 2d5697d6e8..40f710524d 100644
--- a/crates/jcode-app-core/src/tool/patch.rs
+++ b/crates/jcode-app-core/src/tool/patch.rs
@@ -223,7 +223,7 @@ async fn apply_patch_with_diff(
             let old_content = old.as_deref().unwrap_or("");
             tokio::fs::remove_file(path).await?;
             super::edit_stats::record(ctx, old_content, "", old.is_none()).await;
-            let diff = generate_diff(&old_content, "", 1);
+            let diff = generate_diff(old_content, "", 1);
             return Ok(("deleted".to_string(), diff));
         } else {
             return Err(anyhow::anyhow!("file does not exist"));
diff --git a/crates/jcode-app-core/src/tool/todo.rs b/crates/jcode-app-core/src/tool/todo.rs
index dc0fd9ece2..94357ff96c 100644
--- a/crates/jcode-app-core/src/tool/todo.rs
+++ b/crates/jcode-app-core/src/tool/todo.rs
@@ -1,3 +1,4 @@
+#![cfg_attr(test, allow(clippy::await_holding_lock))] // env guards held across async test bodies
 use super::{Tool, ToolContext, ToolOutput};
 use crate::bus::{Bus, BusEvent, TodoEvent};
 use crate::todo::{
@@ -2025,7 +2026,7 @@ mod tests {
             ..before.clone()
         };
 
-        let changes = goal_changes(&[before.clone()], &[after.clone()]);
+        let changes = goal_changes(std::slice::from_ref(&before), std::slice::from_ref(&after));
 
         assert_eq!(changes.len(), 1);
         assert_eq!(changes[0].before.as_ref(), Some(&before));
diff --git a/crates/jcode-app-core/src/turn_cancel_registry.rs b/crates/jcode-app-core/src/turn_cancel_registry.rs
index 1f7a60be4a..2fd8ef0d81 100644
--- a/crates/jcode-app-core/src/turn_cancel_registry.rs
+++ b/crates/jcode-app-core/src/turn_cancel_registry.rs
@@ -153,6 +153,22 @@ impl Drop for ActiveTurnGuard {
     }
 }
 
+/// Whether any turn is currently registered as running for `session_id`.
+///
+/// A cancel that arrives while the session is idle has nothing to stop, but
+/// the "no local task" path still fires the signal and only clears it on a
+/// 500ms timer, because it cannot tell an idle session from one whose turn is
+/// owned by another connection. Any message sent inside that window is aborted
+/// the instant it starts, which looks to the user like a message that vanished
+/// with no reply. The registry already knows whether a turn exists, so ask it
+/// rather than guessing.
+pub fn has_active_turn(session_id: &str) -> bool {
+    ACTIVE_TURNS
+        .lock()
+        .ok()
+        .is_some_and(|map| map.get(session_id).is_some_and(|turns| !turns.is_empty()))
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -277,19 +293,3 @@ mod tests {
         assert!(active_turn_signals(old_id).is_empty());
     }
 }
-
-/// Whether any turn is currently registered as running for `session_id`.
-///
-/// A cancel that arrives while the session is idle has nothing to stop, but
-/// the "no local task" path still fires the signal and only clears it on a
-/// 500ms timer, because it cannot tell an idle session from one whose turn is
-/// owned by another connection. Any message sent inside that window is aborted
-/// the instant it starts, which looks to the user like a message that vanished
-/// with no reply. The registry already knows whether a turn exists, so ask it
-/// rather than guessing.
-pub fn has_active_turn(session_id: &str) -> bool {
-    ACTIVE_TURNS
-        .lock()
-        .ok()
-        .is_some_and(|map| map.get(session_id).is_some_and(|turns| !turns.is_empty()))
-}
diff --git a/crates/jcode-app-core/src/update.rs b/crates/jcode-app-core/src/update.rs
index 31895b639c..872a7b4ede 100644
--- a/crates/jcode-app-core/src/update.rs
+++ b/crates/jcode-app-core/src/update.rs
@@ -653,10 +653,8 @@ fn check_for_main_update_blocking() -> Result<Option<GitHubRelease>> {
             .assets
             .iter()
             .any(|a| a.name.starts_with(asset_name));
-        if has_asset {
-            if release_is_update(&release)? {
-                return Ok(Some(release));
-            }
+        if has_asset && release_is_update(&release)? {
+            return Ok(Some(release));
         }
     }
 
diff --git a/crates/jcode-base/src/account_login/tests.rs b/crates/jcode-base/src/account_login/tests.rs
index eb88dc9478..4a783c6f58 100644
--- a/crates/jcode-base/src/account_login/tests.rs
+++ b/crates/jcode-base/src/account_login/tests.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::await_holding_lock)] // env guards held across async test bodies
+
 use super::*;
 use std::io::{Read, Write};
 
diff --git a/crates/jcode-base/src/auth/cursor.rs b/crates/jcode-base/src/auth/cursor.rs
index c58438d669..dfc950d4cd 100644
--- a/crates/jcode-base/src/auth/cursor.rs
+++ b/crates/jcode-base/src/auth/cursor.rs
@@ -335,8 +335,8 @@ pub fn cursor_auth_file_path() -> Result<PathBuf> {
 
     #[cfg(target_os = "macos")]
     {
-        return crate::storage::user_home_path(".cursor/auth.json")
-            .context("No home directory found for Cursor auth.json");
+        crate::storage::user_home_path(".cursor/auth.json")
+            .context("No home directory found for Cursor auth.json")
     }
 
     #[cfg(not(any(target_os = "windows", target_os = "macos")))]
diff --git a/crates/jcode-base/src/auth/lifecycle.rs b/crates/jcode-base/src/auth/lifecycle.rs
index c0ee77713b..74c3e71640 100644
--- a/crates/jcode-base/src/auth/lifecycle.rs
+++ b/crates/jcode-base/src/auth/lifecycle.rs
@@ -234,10 +234,9 @@ pub fn provider_model_to_select_after_auth_with_configured_default(
                 && route.model == configured
                 && route_matches_activation(route, activation)
         })
+        && selected_model.map(str::trim) != Some(configured)
     {
-        if selected_model.map(str::trim) != Some(configured) {
-            return Some(configured.to_string());
-        }
+        return Some(configured.to_string());
     }
 
     provider_model_to_select_after_auth(activation, selected_model, routes)
diff --git a/crates/jcode-base/src/mcp/pool.rs b/crates/jcode-base/src/mcp/pool.rs
index 587f7c2655..f68455fb45 100644
--- a/crates/jcode-base/src/mcp/pool.rs
+++ b/crates/jcode-base/src/mcp/pool.rs
@@ -422,6 +422,7 @@ pub fn get_shared_pool() -> Option<Arc<SharedMcpPool>> {
     SHARED_POOL.get().cloned()
 }
 
+#[cfg_attr(test, allow(clippy::await_holding_lock))] // env guards held across async test bodies
 #[cfg(test)]
 mod tests {
     use super::{ConnectAttempt, SharedMcpPool};
diff --git a/crates/jcode-base/src/model_usage.rs b/crates/jcode-base/src/model_usage.rs
index 646a0fdff3..624ddec97a 100644
--- a/crates/jcode-base/src/model_usage.rs
+++ b/crates/jcode-base/src/model_usage.rs
@@ -130,7 +130,8 @@ fn legacy() -> HashMap<RouteKey, ModelUsage> {
 pub fn enrich_routes(routes: &mut [ModelRoute]) {
     let mut usage = legacy();
     let mut started: Option<u64> = None;
-    let read = || -> Result<(u64, Vec<(RouteKey, u64, Option<u64>)>)> {
+    type UsageRows = Vec<(RouteKey, u64, Option<u64>)>;
+    let read = || -> Result<(u64, UsageRows)> {
         let db = Connection::open_with_flags(path()?, rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY)?;
         db.busy_timeout(Duration::from_secs(2))?;
         let started = db.query_row("SELECT started FROM tracking WHERE id=1", [], |row| {
diff --git a/crates/jcode-base/src/todo.rs b/crates/jcode-base/src/todo.rs
index 329600a9ef..459506fd3d 100644
--- a/crates/jcode-base/src/todo.rs
+++ b/crates/jcode-base/src/todo.rs
@@ -225,18 +225,18 @@ pub fn build_todo_ownership_continuation_message(todos: &[TodoItem], goals: &[To
             ));
             continue;
         };
-        if !goal
+        if goal
             .delivery_state
-            .is_some_and(|state| state >= required_delivery_state(goal.difficulty))
+            .is_none_or(|state| state < required_delivery_state(goal.difficulty))
         {
             message.push_str(&format!(
                 "\n- Goal \"{}\": carry the work through the complete workflow.",
                 label
             ));
         }
-        if !goal
+        if goal
             .autonomy
-            .is_some_and(|state| state >= Autonomy::NecessaryFollowthrough)
+            .is_none_or(|state| state < Autonomy::NecessaryFollowthrough)
         {
             message.push_str(&format!(
                 "\n- Goal \"{}\": take ownership of the necessary follow-through.",
@@ -277,10 +277,10 @@ pub fn build_todo_ownership_continuation_message(todos: &[TodoItem], goals: &[To
                     | IterationMaturity::ConstraintsExhausted
                     | IterationMaturity::BudgetExhausted
             )
-        ) && !goal
+        ) && goal
             .stopping_evidence
             .as_deref()
-            .is_some_and(|evidence| !evidence.trim().is_empty())
+            .is_none_or(|evidence| evidence.trim().is_empty())
         {
             message.push_str(&format!(
                 "\n- Goal \"{}\": gather more evidence about whether the work should stop.",
diff --git a/crates/jcode-build-support/src/storage_helpers.rs b/crates/jcode-build-support/src/storage_helpers.rs
index 55ba2c6d09..0f50a12ed2 100644
--- a/crates/jcode-build-support/src/storage_helpers.rs
+++ b/crates/jcode-build-support/src/storage_helpers.rs
@@ -63,48 +63,6 @@ pub fn shared_server_binary_path() -> Result<PathBuf> {
     Ok(builds_dir()?.join("shared-server").join(binary_name()))
 }
 
-#[cfg(test)]
-mod tests {
-    use super::resolve_builds_dir;
-    use std::path::PathBuf;
-
-    #[test]
-    fn windows_builds_use_local_app_data() {
-        let resolved = resolve_builds_dir(
-            None,
-            Some(PathBuf::from("/local-app-data")),
-            PathBuf::from("/home/test/.jcode"),
-            true,
-        );
-
-        assert_eq!(resolved, PathBuf::from("/local-app-data/jcode/builds"));
-    }
-
-    #[test]
-    fn jcode_home_override_wins_on_windows() {
-        let resolved = resolve_builds_dir(
-            Some(PathBuf::from("/isolated-jcode")),
-            Some(PathBuf::from("/local-app-data")),
-            PathBuf::from("/home/test/.jcode"),
-            true,
-        );
-
-        assert_eq!(resolved, PathBuf::from("/isolated-jcode/builds"));
-    }
-
-    #[test]
-    fn non_windows_builds_stay_under_jcode_home() {
-        let resolved = resolve_builds_dir(
-            None,
-            Some(PathBuf::from("/ignored/local-app-data")),
-            PathBuf::from("/home/test/.jcode"),
-            false,
-        );
-
-        assert_eq!(resolved, PathBuf::from("/home/test/.jcode/builds"));
-    }
-}
-
 /// Get path to canary binary
 pub fn canary_binary_path() -> Result<PathBuf> {
     Ok(builds_dir()?.join("canary").join(binary_name()))
@@ -281,3 +239,45 @@ pub fn clear_build_progress() -> Result<()> {
     invalidate_build_progress_cache();
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::resolve_builds_dir;
+    use std::path::PathBuf;
+
+    #[test]
+    fn windows_builds_use_local_app_data() {
+        let resolved = resolve_builds_dir(
+            None,
+            Some(PathBuf::from("/local-app-data")),
+            PathBuf::from("/home/test/.jcode"),
+            true,
+        );
+
+        assert_eq!(resolved, PathBuf::from("/local-app-data/jcode/builds"));
+    }
+
+    #[test]
+    fn jcode_home_override_wins_on_windows() {
+        let resolved = resolve_builds_dir(
+            Some(PathBuf::from("/isolated-jcode")),
+            Some(PathBuf::from("/local-app-data")),
+            PathBuf::from("/home/test/.jcode"),
+            true,
+        );
+
+        assert_eq!(resolved, PathBuf::from("/isolated-jcode/builds"));
+    }
+
+    #[test]
+    fn non_windows_builds_stay_under_jcode_home() {
+        let resolved = resolve_builds_dir(
+            None,
+            Some(PathBuf::from("/ignored/local-app-data")),
+            PathBuf::from("/home/test/.jcode"),
+            false,
+        );
+
+        assert_eq!(resolved, PathBuf::from("/home/test/.jcode/builds"));
+    }
+}
diff --git a/crates/jcode-core/src/stdin_detect.rs b/crates/jcode-core/src/stdin_detect.rs
index a079379790..5d4f89e28b 100644
--- a/crates/jcode-core/src/stdin_detect.rs
+++ b/crates/jcode-core/src/stdin_detect.rs
@@ -330,13 +330,13 @@ mod macos {
         let num_threads = ret as usize / mem::size_of::<u64>();
 
         // Check each thread's state
-        for i in 0..num_threads {
+        for &thread_id in &thread_ids[..num_threads] {
             let mut tinfo: proc_threadinfo = unsafe { mem::zeroed() };
             let ret = unsafe {
                 proc_pidinfo(
                     pid,
                     PROC_PIDTHREADINFO,
-                    thread_ids[i],
+                    thread_id,
                     &mut tinfo as *mut _ as *mut libc::c_void,
                     mem::size_of::<proc_threadinfo>() as i32,
                 )
diff --git a/crates/jcode-core/src/stdin_detect_tests.rs b/crates/jcode-core/src/stdin_detect_tests.rs
index 4a4f38c6bc..2e62b575e6 100644
--- a/crates/jcode-core/src/stdin_detect_tests.rs
+++ b/crates/jcode-core/src/stdin_detect_tests.rs
@@ -1,4 +1,5 @@
 use super::*;
+#[cfg(target_os = "linux")]
 use std::process::{Command, Stdio};
 
 #[test]
diff --git a/crates/jcode-harness-api-server/src/lib.rs b/crates/jcode-harness-api-server/src/lib.rs
index 09eb652d39..8b9a61dac0 100644
--- a/crates/jcode-harness-api-server/src/lib.rs
+++ b/crates/jcode-harness-api-server/src/lib.rs
@@ -480,6 +480,10 @@ mod public_acceptance_tests {
         }
     }
 
+    // Guard held across await is intentional: it serializes JCODE_HOME
+    // across tests for the whole async body since the server under test
+    // inherits the env. await_holding_lock fires on fn scope, so allow here.
+    #[allow(clippy::await_holding_lock)]
     #[tokio::test(flavor = "multi_thread")]
     async fn public_socket_keeps_its_attachment_after_another_sessions_state() {
         let _home_lock = translate::jcode_home_test_lock();
diff --git a/crates/jcode-harness-api-server/src/translate.rs b/crates/jcode-harness-api-server/src/translate.rs
index ce0b93ba92..5c22edd937 100644
--- a/crates/jcode-harness-api-server/src/translate.rs
+++ b/crates/jcode-harness-api-server/src/translate.rs
@@ -83,6 +83,10 @@ fn flatten_content(content: &Value) -> String {
 use serde_json::{Value, json};
 
 /// Where a translated client request should go.
+/// `Reply` is 9x `Legacy` because `ServerFrame` carries rich reply payloads;
+/// boxing every construction site costs more churn than the enum's
+/// short-lived, low-frequency use justifies.
+#[allow(clippy::large_enum_variant)]
 #[derive(Debug)]
 pub enum Outbound {
     /// Forward to the legacy daemon connection.
@@ -470,7 +474,9 @@ impl BridgeState {
                 vec![
                     Outbound::Legacy(subscribe),
                     Outbound::Legacy(json!({"type": "state", "id": state_id})),
-                    Outbound::Legacy(json!({"type": "get_model_catalog", "id": catalog_id, "subscribe_usage_updates": true})),
+                    Outbound::Legacy(
+                        json!({"type": "get_model_catalog", "id": catalog_id, "subscribe_usage_updates": true}),
+                    ),
                 ]
             }
             "send_message" => {
@@ -1852,7 +1858,11 @@ impl BridgeState {
             .windows(needle.len())
             .enumerate()
             .filter_map(|(at, window)| (window == needle.as_bytes()).then_some(at + needle.len()));
-        let start = if last { starts.last()? } else { starts.next()? };
+        let start = if last {
+            starts.next_back()?
+        } else {
+            starts.next()?
+        };
         Option::<String>::deserialize(&mut serde_json::Deserializer::from_slice(&bytes[start..]))
             .ok()
             .flatten()
@@ -2069,7 +2079,7 @@ impl BridgeState {
                 .flat_map(|handle| handle.join().unwrap_or_default())
                 .collect::<Vec<_>>()
         });
-        ids.sort_unstable_by(|left, right| right.0.cmp(&left.0));
+        ids.sort_unstable_by_key(|(started, _)| std::cmp::Reverse(*started));
         Self::write_bootstrap_recent_session_index(&ids);
         if let Some(limit) = limit {
             ids.truncate(limit);
diff --git a/crates/jcode-harness-api-server/src/translate_tests.rs b/crates/jcode-harness-api-server/src/translate_tests.rs
index 26da3f61c3..f542dc1d70 100644
--- a/crates/jcode-harness-api-server/src/translate_tests.rs
+++ b/crates/jcode-harness-api-server/src/translate_tests.rs
@@ -6,8 +6,10 @@ use std::sync::MutexGuard;
 
 #[test]
 fn token_usage_preserves_cache_creation_and_missing_counters() {
-    let mut state = BridgeState::default();
-    state.session_id = Some("s1".into());
+    let mut state = BridgeState {
+        session_id: Some("s1".into()),
+        ..Default::default()
+    };
     for cache_creation_input in [None, Some(0), Some(42)] {
         let mut legacy = json!({
             "type": "tokens", "input": 10, "output": 5, "cache_read_input": 2
@@ -1759,7 +1761,7 @@ fn archive_restore_and_retention_are_reversible_and_owner_only() {
         .iter()
         .find(|session| session.session_id == "old_session")
         .expect("old session remains restorable");
-    assert_eq!(old.archived, true);
+    assert!(old.archived);
     assert!(old.archived_at_ms.is_some());
     let recent = sessions
         .iter()
@@ -2470,17 +2472,26 @@ fn history_response_stats_cross_real_render_protocol_and_sdk_boundary() {
         {"id":"a","role":"assistant","content":[{"type":"text","text":"answer"}],
             "token_usage":{"input_tokens":123,"output_tokens":45,"cache_read_input_tokens":7,"cache_creation_input_tokens":8}}
     ])).unwrap();
-    let legacy: Vec<_> = jcode_base::session::render_messages(&session).into_iter()
+    let legacy: Vec<_> = jcode_base::session::render_messages(&session)
+        .into_iter()
         .map(|row| jcode_base::protocol::HistoryMessage {
-            role: row.role, content: row.content, tool_calls: None, tool_data: row.tool_data,
+            role: row.role,
+            content: row.content,
+            tool_calls: None,
+            tool_data: row.tool_data,
             response_stats: row.response_stats,
-        }).collect();
+        })
+        .collect();
     let mut state = state_with_session();
     let out = state.api_request_to_legacy(&json!({"req":"get_history", "id":46}));
-    let Outbound::Legacy(request) = &out[0] else { panic!("expected history request") };
+    let Outbound::Legacy(request) = &out[0] else {
+        panic!("expected history request")
+    };
     let frames = state.legacy_event_to_api(&json!({"type":"history", "id":request["id"],
         "messages":legacy,"activity":{"is_processing":false}}));
-    let ApiEvent::History { messages, .. } = &frames[0].event else { panic!("expected history") };
+    let ApiEvent::History { messages, .. } = &frames[0].event else {
+        panic!("expected history")
+    };
     let stats = messages[1].response_stats.as_ref().unwrap();
     assert_eq!(stats.input_tokens, Some(123));
     assert_eq!(stats.output_tokens, Some(45));
@@ -2564,8 +2575,10 @@ fn attachment_recovery_preserves_directive_in_both_history_state_orders() {
 
 #[test]
 fn attachment_recovery_ignores_wrong_session_and_request_without_consuming_intent() {
-    let mut state = BridgeState::default();
-    state.session_id = Some("previous".into());
+    let mut state = BridgeState {
+        session_id: Some("previous".into()),
+        ..Default::default()
+    };
     let (history, _) = recovery_attach(&mut state, Some("recover"));
     let mut unrelated = history.clone();
     unrelated["session_id"] = json!("other");
diff --git a/crates/jcode-harness-api/src/edit_stats.rs b/crates/jcode-harness-api/src/edit_stats.rs
index d2fad8520e..9bd96dccd5 100644
--- a/crates/jcode-harness-api/src/edit_stats.rs
+++ b/crates/jcode-harness-api/src/edit_stats.rs
@@ -156,10 +156,9 @@ fn count_legacy_messages(messages: &[Value]) -> SessionEditStats {
                             | "patch"
                             | "apply_patch"
                             | "batch"
-                    ) {
-                        if let Some(id) = block["id"].as_str() {
-                            calls.insert(id, (name, &block["input"]));
-                        }
+                    ) && let Some(id) = block["id"].as_str()
+                    {
+                        calls.insert(id, (name, &block["input"]));
                     }
                 }
                 Some("tool_result") if block["is_error"] != true => {
@@ -334,10 +333,10 @@ fn scan_queue() {
         });
         let mut cache = CACHE.lock().unwrap_or_else(|p| p.into_inner());
         cache.pending.remove(&key);
-        if cache.entries.len() >= 512 {
-            if let Some(key) = cache.entries.keys().next().cloned() {
-                cache.entries.remove(&key);
-            }
+        if cache.entries.len() >= 512
+            && let Some(key) = cache.entries.keys().next().cloned()
+        {
+            cache.entries.remove(&key);
         }
         cache.entries.insert(key, (current, stats));
     }
diff --git a/crates/jcode-harness-api/src/harness_api_tests/capability_coverage.rs b/crates/jcode-harness-api/src/harness_api_tests/capability_coverage.rs
index 48e42f7c4d..91d9ab76db 100644
--- a/crates/jcode-harness-api/src/harness_api_tests/capability_coverage.rs
+++ b/crates/jcode-harness-api/src/harness_api_tests/capability_coverage.rs
@@ -27,7 +27,10 @@ enum Disposition {
     /// model, and would mean nothing to a third-party client.
     ClientInternal,
     /// A real gap. Worth exposing, not yet done. Every entry needs a reason
-    /// that says what a client cannot build without it.
+    /// that says what a client cannot build without it. The ledger currently
+    /// has zero Gap entries; the variant stays so adding one is a one-line
+    /// change and the exhaustive match below keeps its reporting arm.
+    #[allow(dead_code)]
     Gap(&'static str),
 }
 
@@ -83,8 +86,8 @@ const LEDGER: &[(&str, Disposition)] = &[
 /// Requests the reference clients (TUI) send to the daemon.
 fn reference_client_requests() -> BTreeSet<String> {
     let mut found = BTreeSet::new();
-    for dir in ["../jcode-tui/src"] {
-        let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join(dir);
+    {
+        let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../jcode-tui/src");
         collect_requests(&root, &mut found);
     }
     // covered by construction and would otherwise pollute the diff.
diff --git a/crates/jcode-harness-api/src/harness_api_tests/schema_snapshot.rs b/crates/jcode-harness-api/src/harness_api_tests/schema_snapshot.rs
index f5601b72a2..f0698f30f9 100644
--- a/crates/jcode-harness-api/src/harness_api_tests/schema_snapshot.rs
+++ b/crates/jcode-harness-api/src/harness_api_tests/schema_snapshot.rs
@@ -336,10 +336,10 @@ fn enum_variant_fields(file: &str, enum_name: &str) -> Vec<(String, Vec<String>)
         };
         if rest.starts_with(' ') {
             // A field line inside the variant currently being collected.
-            if let Some((_, fields)) = out.last_mut() {
-                if let Some(name) = field_name(rest) {
-                    fields.push(name);
-                }
+            if let Some((_, fields)) = out.last_mut()
+                && let Some(name) = field_name(rest)
+            {
+                fields.push(name);
             }
             continue;
         }
diff --git a/crates/jcode-message-types/src/lib.rs b/crates/jcode-message-types/src/lib.rs
index 4466771887..612714322e 100644
--- a/crates/jcode-message-types/src/lib.rs
+++ b/crates/jcode-message-types/src/lib.rs
@@ -868,8 +868,8 @@ mod tests {
         };
 
         assert_eq!(
-            cache_relevant_message_hashes(&[sent.clone()]),
-            cache_relevant_message_hashes(&[persisted.clone()]),
+            cache_relevant_message_hashes(std::slice::from_ref(&sent)),
+            cache_relevant_message_hashes(std::slice::from_ref(&persisted)),
             "non-transmitted metadata must not change the cache-relevant hash"
         );
         assert_eq!(
diff --git a/crates/jcode-protocol/src/wire.rs b/crates/jcode-protocol/src/wire.rs
index e434736a87..7ebb276fc9 100644
--- a/crates/jcode-protocol/src/wire.rs
+++ b/crates/jcode-protocol/src/wire.rs
@@ -1305,7 +1305,9 @@ pub enum ServerEvent {
 
     /// Usage delta for a route, independent of catalog availability or Agent locks.
     #[serde(rename = "model_usage_updated")]
-    ModelUsageUpdated { route: jcode_provider_core::ModelRoute },
+    ModelUsageUpdated {
+        route: jcode_provider_core::ModelRoute,
+    },
 
     /// Available models updated (pushed after auth changes)
     #[serde(rename = "available_models_updated")]
diff --git a/crates/jcode-provider-metadata/src/lib.rs b/crates/jcode-provider-metadata/src/lib.rs
index a68bf1cf83..c0da96f49d 100644
--- a/crates/jcode-provider-metadata/src/lib.rs
+++ b/crates/jcode-provider-metadata/src/lib.rs
@@ -459,7 +459,11 @@ mod tests {
         assert_eq!(NOVITA_PROFILE.api_key_env, "NOVITA_API_KEY");
         assert_eq!(NOVITA_PROFILE.env_file, "novita.env");
         assert_eq!(NOVITA_PROFILE.default_model, Some("zai-org/glm-5.3"));
-        assert!(NOVITA_PROFILE.requires_api_key);
+        // Compile-known profile pins; kept as readable regression guards.
+        #[allow(clippy::assertions_on_constants)]
+        {
+            assert!(NOVITA_PROFILE.requires_api_key);
+        }
         assert!(openai_compatible_profiles().contains(&NOVITA_PROFILE));
         for input in ["novita", "novita-ai", "novita.ai", " NOVITA "] {
             assert_eq!(resolve_login_provider(input), Some(NOVITA_LOGIN_PROVIDER));
@@ -546,7 +550,11 @@ mod tests {
         assert_eq!(BELVEDIR_PROFILE.api_key_env, "BELVEDIR_API_KEY");
         assert_eq!(BELVEDIR_PROFILE.env_file, "belvedir.env");
         assert_eq!(BELVEDIR_PROFILE.default_model, Some("auto"));
-        assert!(BELVEDIR_PROFILE.requires_api_key);
+        // Compile-known profile pins; kept as readable regression guards.
+        #[allow(clippy::assertions_on_constants)]
+        {
+            assert!(BELVEDIR_PROFILE.requires_api_key);
+        }
 
         let provider = resolve_login_provider("belvedir.ai").expect("Belvedir alias resolves");
         assert_eq!(provider.id, "belvedir");
diff --git a/crates/jcode-provider-openai-runtime/src/openai_tests/persistent_terminal.rs b/crates/jcode-provider-openai-runtime/src/openai_tests/persistent_terminal.rs
index 46b129171d..8ff32258ae 100644
--- a/crates/jcode-provider-openai-runtime/src/openai_tests/persistent_terminal.rs
+++ b/crates/jcode-provider-openai-runtime/src/openai_tests/persistent_terminal.rs
@@ -1,5 +1,6 @@
 // Public Provider::complete + EventStream regressions using a loopback Responses
 // server. These are deterministic protocol fixtures, not live OpenAI acceptance.
+#[allow(clippy::await_holding_lock)] // env guard held across async body
 async fn persistent_terminal_public_case(
     error_kind: &str,
     code: Option<&str>,
@@ -136,16 +137,19 @@ async fn persistent_terminal_public_case(
     );
 }
 
+#[allow(clippy::await_holding_lock)] // env guard held across async body
 #[tokio::test]
 async fn persistent_terminal_public_stream_ends() {
     persistent_terminal_public_case("error", None, false).await;
 }
 
+#[allow(clippy::await_holding_lock)] // env guard held across async body
 #[tokio::test]
 async fn persistent_terminal_public_next_call_not_stalled() {
     persistent_terminal_public_case("response.failed", None, true).await;
 }
 
+#[allow(clippy::await_holding_lock)] // env guard held across async body
 #[tokio::test]
 async fn persistent_terminal_public_missing_previous_full_replay() {
     persistent_terminal_public_case("error", Some("previous_response_not_found"), false).await;
@@ -153,6 +157,7 @@ async fn persistent_terminal_public_missing_previous_full_replay() {
 
 // Synthetic concurrency regression: a mutex waiter is queued before failure,
 // so a caller-side clear after the helper returns cannot hide a stale handoff.
+#[allow(clippy::await_holding_lock)] // env guard held across async body
 #[tokio::test]
 async fn persistent_terminal_failure_invalidates_before_mutex_handoff() {
     let _env_lock = jcode_base::storage::lock_test_env();
diff --git a/crates/jcode-provider-openai-runtime/src/openai_tests/websocket_prewarm.rs b/crates/jcode-provider-openai-runtime/src/openai_tests/websocket_prewarm.rs
index 134b96c6de..77b5020352 100644
--- a/crates/jcode-provider-openai-runtime/src/openai_tests/websocket_prewarm.rs
+++ b/crates/jcode-provider-openai-runtime/src/openai_tests/websocket_prewarm.rs
@@ -42,6 +42,7 @@ async fn wait_for_prewarm(slot: &openai_websocket_prewarm::PrewarmSlot) {
     .expect("prewarm should become ready");
 }
 
+#[allow(clippy::await_holding_lock)] // env guard held across async body
 #[tokio::test]
 async fn websocket_v2_prewarm_is_adopted_by_complete_without_losing_request_state() {
     let _lock = jcode_base::storage::lock_test_env();
@@ -55,6 +56,9 @@ async fn websocket_v2_prewarm_is_adopted_by_complete_without_losing_request_stat
 
     let server = tokio::spawn(async move {
         let (stream, _) = listener.accept().await.expect("accept prewarm connection");
+        // Err type is tungstenite's own Response<Option<String>>; its size is
+        // fixed by the accept_hdr_async callback signature, not by this test.
+        #[allow(clippy::result_large_err)]
         let mut socket = tokio_tungstenite::accept_hdr_async(
             stream,
             |request: &tokio_tungstenite::tungstenite::handshake::server::Request,
@@ -204,6 +208,7 @@ async fn websocket_v2_prewarm_is_adopted_by_complete_without_losing_request_stat
     server.await.expect("local websocket server");
 }
 
+#[allow(clippy::await_holding_lock)] // env guard held across async body
 #[tokio::test]
 async fn unfinished_or_incompatible_prewarm_is_cancelled_without_foreground_wait() {
     let _lock = jcode_base::storage::lock_test_env();
@@ -245,6 +250,7 @@ async fn unfinished_or_incompatible_prewarm_is_cancelled_without_foreground_wait
     server.await.expect("unfinished server");
 }
 
+#[allow(clippy::await_holding_lock)] // env guard held across async body
 #[tokio::test]
 async fn ready_prewarm_with_different_settings_is_invalidated() {
     let _lock = jcode_base::storage::lock_test_env();
@@ -280,6 +286,7 @@ async fn ready_prewarm_with_different_settings_is_invalidated() {
     server.await.expect("settings mismatch server");
 }
 
+#[allow(clippy::await_holding_lock)] // env guard held across async body
 #[tokio::test]
 async fn rejected_warmup_is_not_adopted() {
     let _lock = jcode_base::storage::lock_test_env();
diff --git a/crates/jcode-provider-openai-runtime/src/openai_usage_recording.rs b/crates/jcode-provider-openai-runtime/src/openai_usage_recording.rs
index eecae1e3fa..f17b2b18d9 100644
--- a/crates/jcode-provider-openai-runtime/src/openai_usage_recording.rs
+++ b/crates/jcode-provider-openai-runtime/src/openai_usage_recording.rs
@@ -95,6 +95,7 @@ impl OAuthUsageRecorder {
     }
 }
 
+#[cfg_attr(test, allow(clippy::await_holding_lock))] // env guards held across async test bodies
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/jcode-provider-openrouter-runtime/src/openrouter_catalog_merge_tests.rs b/crates/jcode-provider-openrouter-runtime/src/openrouter_catalog_merge_tests.rs
index 66e170f195..58460bf705 100644
--- a/crates/jcode-provider-openrouter-runtime/src/openrouter_catalog_merge_tests.rs
+++ b/crates/jcode-provider-openrouter-runtime/src/openrouter_catalog_merge_tests.rs
@@ -1,6 +1,7 @@
 //! Regression tests for static-model / live-catalog merge behavior
 //! across built-in and user-declared OpenAI-compatible provider profiles.
 
+#![allow(clippy::await_holding_lock)] // env guards held across async test bodies
 use crate::tests::{ENV_LOCK, EnvVarGuard};
 
 /// Minimal one-shot `/models` endpoint: serves `body` to the first request.
diff --git a/crates/jcode-sdk/src/auth.rs b/crates/jcode-sdk/src/auth.rs
index d0e2a2573b..9f08495bf0 100644
--- a/crates/jcode-sdk/src/auth.rs
+++ b/crates/jcode-sdk/src/auth.rs
@@ -412,10 +412,10 @@ impl FlowInner {
         if matches!(operation, Operation::Callback | Operation::Code) {
             command.arg("-");
         }
-        if operation == Operation::Begin {
-            if let Some(account) = &self.account {
-                command.arg("--account").arg(account);
-            }
+        if operation == Operation::Begin
+            && let Some(account) = &self.account
+        {
+            command.arg("--account").arg(account);
         }
         command
             .stdin(Stdio::piped())
diff --git a/crates/jcode-sdk/src/client.rs b/crates/jcode-sdk/src/client.rs
index 59029e667e..b2a58f4992 100644
--- a/crates/jcode-sdk/src/client.rs
+++ b/crates/jcode-sdk/src/client.rs
@@ -106,9 +106,9 @@ impl Transport for UnixTransport {
         #[cfg(unix)]
         {
             let socket = self.0.try_clone().ok()?;
-            return Some(Arc::new(move || {
+            Some(Arc::new(move || {
                 let _ = socket.shutdown(std::net::Shutdown::Both);
-            }));
+            }))
         }
         #[cfg(windows)]
         {
@@ -307,12 +307,15 @@ fn stop_global_stream(control: &GlobalEventControl, error: Option<Error>) {
     drop(children);
 }
 
+/// Live subscription: (id, session filter, sink).
+type Subscriber = (u64, Option<String>, Sender<ApiEvent>);
+
 struct Inner {
     writer: Mutex<Box<dyn Write + Send>>,
     /// Requests waiting for their `reply_to` frame.
     pending: Mutex<HashMap<u64, Sender<ServerFrame>>>,
     /// Live subscriptions: (id, session filter, sink).
-    subscribers: Mutex<Vec<(u64, Option<String>, Sender<ApiEvent>)>>,
+    subscribers: Mutex<Vec<Subscriber>>,
     next_id: AtomicU64,
     next_sub: AtomicU64,
     closed: AtomicBool,
@@ -357,10 +360,10 @@ impl Clone for JcodeClient {
 
 impl Drop for JcodeClient {
     fn drop(&mut self) {
-        if self.inner.client_handles.fetch_sub(1, Ordering::AcqRel) == 1 {
-            if let Some(shutdown) = &self.inner.shutdown {
-                shutdown();
-            }
+        if self.inner.client_handles.fetch_sub(1, Ordering::AcqRel) == 1
+            && let Some(shutdown) = &self.inner.shutdown
+        {
+            shutdown();
         }
     }
 }
@@ -1479,11 +1482,8 @@ fn start_global_child(parent: &JcodeClient, control: &Arc<GlobalEventControl>, s
 /// The reader thread: correlates replies, fans stream events out.
 fn spawn_reader(inner: Arc<Inner>, mut reader: Box<dyn BufRead + Send>) {
     std::thread::spawn(move || {
-        loop {
-            let frame: ServerFrame = match read_frame(&mut reader) {
-                Ok(frame) => frame,
-                Err(_) => break,
-            };
+        while let Ok(frame) = read_frame(&mut reader) {
+            let frame: ServerFrame = frame;
             // Unknown kinds are skipped silently, per the protocol's
             // forward-compatibility rule.
             if matches!(frame.event, ApiEvent::Unknown) {
diff --git a/crates/jcode-sdk/src/launch.rs b/crates/jcode-sdk/src/launch.rs
index 66fcd9267a..56c0ebf7a2 100644
--- a/crates/jcode-sdk/src/launch.rs
+++ b/crates/jcode-sdk/src/launch.rs
@@ -200,11 +200,11 @@ pub fn launch_instance(options: &LaunchOptions) -> Result<LaunchedInstance> {
             remove_ephemeral_home(&jcode_home, Duration::ZERO);
         }
     };
-    if options.inherit_logins {
-        if let Err(error) = inherit_credentials(&user_jcode_home(), &jcode_home) {
-            cleanup_on_error();
-            return Err(error);
-        }
+    if options.inherit_logins
+        && let Err(error) = inherit_credentials(&user_jcode_home(), &jcode_home)
+    {
+        cleanup_on_error();
+        return Err(error);
     }
 
     let binary = options
@@ -700,7 +700,7 @@ fn home_dir() -> PathBuf {
 pub fn user_app_config_dir() -> PathBuf {
     #[cfg(target_os = "macos")]
     {
-        return home_dir().join("Library/Application Support/jcode");
+        home_dir().join("Library/Application Support/jcode")
     }
     #[cfg(target_os = "windows")]
     {
diff --git a/crates/jcode-sdk/src/ssh.rs b/crates/jcode-sdk/src/ssh.rs
index 12f2e935d4..d631757b3e 100644
--- a/crates/jcode-sdk/src/ssh.rs
+++ b/crates/jcode-sdk/src/ssh.rs
@@ -213,27 +213,27 @@ impl SshProcess {
     }
 
     pub(crate) fn shutdown(&self) {
-        if let Ok(mut child) = self.child.lock() {
-            if let Some(mut child) = child.take() {
-                // A dedicated process group also closes ProxyCommand helpers.
-                #[cfg(unix)]
-                unsafe {
-                    libc::kill(-(child.id() as i32), libc::SIGKILL);
-                }
-                let _ = child.kill();
-                if let Ok(status) = child.wait() {
-                    if let Ok(mut saved) = self.status.lock() {
-                        *saved = Some(status);
-                    }
-                }
+        if let Ok(mut child) = self.child.lock()
+            && let Some(mut child) = child.take()
+        {
+            // A dedicated process group also closes ProxyCommand helpers.
+            #[cfg(unix)]
+            unsafe {
+                libc::kill(-(child.id() as i32), libc::SIGKILL);
+            }
+            let _ = child.kill();
+            if let Ok(status) = child.wait()
+                && let Ok(mut saved) = self.status.lock()
+            {
+                *saved = Some(status);
             }
         }
         // Usually EOF arrives immediately. Never hang cleanup on an inherited
         // stderr handle held by a configured external SSH helper.
-        if let Ok(mut done) = self.stderr_done.lock() {
-            if let Some(done) = done.take() {
-                let _ = done.recv_timeout(Duration::from_millis(100));
-            }
+        if let Ok(mut done) = self.stderr_done.lock()
+            && let Some(done) = done.take()
+        {
+            let _ = done.recv_timeout(Duration::from_millis(100));
         }
     }
 
diff --git a/crates/jcode-sdk/src/structured.rs b/crates/jcode-sdk/src/structured.rs
index d2056f94ce..c88cff34a1 100644
--- a/crates/jcode-sdk/src/structured.rs
+++ b/crates/jcode-sdk/src/structured.rs
@@ -492,7 +492,7 @@ fn sort_json(value: &Value) -> Value {
         Value::Array(values) => Value::Array(values.iter().map(sort_json).collect()),
         Value::Object(values) => {
             let mut entries: Vec<_> = values.iter().collect();
-            entries.sort_by(|(left, _), (right, _)| left.cmp(right));
+            entries.sort_by_key(|(key, _)| *key);
             Value::Object(
                 entries
                     .into_iter()
diff --git a/crates/jcode-sdk/tests/client_behavior.rs b/crates/jcode-sdk/tests/client_behavior.rs
index f007daa52c..bfaffc2cfd 100644
--- a/crates/jcode-sdk/tests/client_behavior.rs
+++ b/crates/jcode-sdk/tests/client_behavior.rs
@@ -57,11 +57,8 @@ fn fake_harness(handle: impl Fn(&ClientFrame, &mut dyn Write) + Send + 'static)
     std::thread::spawn(move || {
         let mut reader = BufReader::new(theirs.try_clone().expect("clone"));
         let mut writer = theirs;
-        loop {
-            let frame: ClientFrame = match read_frame(&mut reader) {
-                Ok(frame) => frame,
-                Err(_) => break,
-            };
+        while let Ok(frame) = read_frame(&mut reader) {
+            let frame: ClientFrame = frame;
             // The handshake is boilerplate every test would repeat.
             if let ApiRequest::Hello { .. } = frame.request {
                 let reply = ServerFrame {
diff --git a/crates/jcode-setup-hints/src/lib.rs b/crates/jcode-setup-hints/src/lib.rs
index fe072469fc..a774434153 100644
--- a/crates/jcode-setup-hints/src/lib.rs
+++ b/crates/jcode-setup-hints/src/lib.rs
@@ -702,7 +702,7 @@ pub fn run_setup_hotkey(
                     "    \x1b[1mCmd+Shift+'\x1b[0m new jcode self-dev session (last jcode repo)"
                 );
                 install_cli_launch_hints_notice();
-                return Ok(());
+                Ok(())
             }
             Err(e) => {
                 eprintln!("  \x1b[31m✗\x1b[0m Failed: {}", e);
@@ -1330,7 +1330,7 @@ pub fn maybe_show_setup_hints() -> Option<StartupHints> {
 
     #[cfg(target_os = "macos")]
     {
-        if state.launch_count % 3 != 0 {
+        if !state.launch_count.is_multiple_of(3) {
             return startup_hints;
         }
 
@@ -1349,7 +1349,7 @@ pub fn maybe_show_setup_hints() -> Option<StartupHints> {
             return nudge_macos_ghostty(&mut state);
         }
 
-        return startup_hints;
+        startup_hints
     }
 
     #[cfg(windows)]
@@ -1433,13 +1433,13 @@ fn detect_linux_compositor() -> Option<linux_env::LinuxCompositor> {
 }
 
 /// Path to the niri config file, honoring `$XDG_CONFIG_HOME`.
-#[cfg(any(test, target_os = "linux"))]
+#[cfg(target_os = "linux")]
 fn niri_config_path() -> Option<PathBuf> {
     Some(xdg_config_home()?.join("niri").join("config.kdl"))
 }
 
 /// `$XDG_CONFIG_HOME`, defaulting to `~/.config`.
-#[cfg(any(test, target_os = "linux"))]
+#[cfg(target_os = "linux")]
 fn xdg_config_home() -> Option<PathBuf> {
     std::env::var_os("XDG_CONFIG_HOME")
         .map(PathBuf::from)
@@ -1582,7 +1582,7 @@ fn linux_hotkey_setup_action(
 
 /// Pick a terminal emulator to launch jcode in on Linux. Honors `$TERMINAL`,
 /// otherwise probes common emulators on `PATH`, falling back to `kitty`.
-#[cfg(any(test, target_os = "linux"))]
+#[cfg(target_os = "linux")]
 fn linux_launch_terminal() -> String {
     if let Ok(t) = std::env::var("TERMINAL")
         && !t.trim().is_empty()
@@ -1606,7 +1606,7 @@ fn linux_launch_terminal() -> String {
 }
 
 /// Whether `name` resolves to an executable on `$PATH`.
-#[cfg(any(test, target_os = "linux"))]
+#[cfg(target_os = "linux")]
 fn binary_on_path(name: &str) -> bool {
     let Some(paths) = std::env::var_os("PATH") else {
         return false;
@@ -1619,7 +1619,7 @@ fn binary_on_path(name: &str) -> bool {
 
 /// Resolve the configured launch hotkeys into concrete Linux hotkeys, with each
 /// directory sentinel expanded to a real path.
-#[cfg(any(test, target_os = "linux"))]
+#[cfg(target_os = "linux")]
 fn resolve_linux_hotkeys() -> Vec<linux_niri::NiriHotkey> {
     let config = load_launch_hotkeys_config();
     let exe_path = std::env::current_exe()
@@ -2451,7 +2451,7 @@ pub fn run_setup_launcher() -> Result<()> {
                 );
                 eprintln!();
                 eprintln!("  Tip: pin Jcode.app to your Dock or launch it with Cmd+Space.");
-                return Ok(());
+                Ok(())
             }
             Err(e) => {
                 eprintln!("  \x1b[31m✗\x1b[0m Failed: {}", e);
diff --git a/crates/jcode-setup-hints/src/linux_env.rs b/crates/jcode-setup-hints/src/linux_env.rs
index 3acbfe1ac7..e2d023e7c1 100644
--- a/crates/jcode-setup-hints/src/linux_env.rs
+++ b/crates/jcode-setup-hints/src/linux_env.rs
@@ -58,6 +58,7 @@ pub(crate) enum LinuxCompositor {
 }
 
 impl LinuxCompositor {
+    #[cfg(target_os = "linux")]
     pub(crate) fn name(&self) -> &'static str {
         match self {
             LinuxCompositor::Niri => "niri",
@@ -683,7 +684,8 @@ mod tests {
 
     #[test]
     fn detects_compositors_from_sockets_and_desktop_names() {
-        let cases: Vec<(Vec<(&str, &str)>, Option<LinuxCompositor>)> = vec![
+        type EnvCase = (Vec<(&'static str, &'static str)>, Option<LinuxCompositor>);
+        let cases: Vec<EnvCase> = vec![
             (
                 vec![("NIRI_SOCKET", "/run/niri.sock")],
                 Some(LinuxCompositor::Niri),
diff --git a/crates/jcode-telemetry-core/src/lib.rs b/crates/jcode-telemetry-core/src/lib.rs
index d6f7faf3ca..77fafc6d8b 100644
--- a/crates/jcode-telemetry-core/src/lib.rs
+++ b/crates/jcode-telemetry-core/src/lib.rs
@@ -21,23 +21,35 @@ use serde_json::Value;
 use state_support::*;
 use std::collections::HashSet;
 use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::mpsc::{SyncSender, TrySendError, sync_channel};
+#[cfg(not(test))]
+use std::sync::mpsc::TrySendError;
+use std::sync::mpsc::{SyncSender, sync_channel};
 use std::sync::{Mutex, OnceLock};
 use std::time::{Duration, Instant};
 
 const TELEMETRY_ENDPOINT: &str = "https://telemetry.jcode.sh/v1/event";
 const TRANSCRIPT_ENDPOINT: &str = "https://telemetry.jcode.sh/v1/transcript";
+// The background HTTP delivery machinery below is only wired up in
+// cfg(not(test)) builds; tests stub delivery into TEST_EMITTED_PAYLOADS,
+// so these items look dead in the test build.
+#[cfg_attr(test, allow(dead_code))]
 const ASYNC_SEND_TIMEOUT: Duration = Duration::from_secs(5);
+#[cfg_attr(test, allow(dead_code))]
 const BACKGROUND_QUEUE_CAPACITY: usize = 2048;
 const BLOCKING_INSTALL_TIMEOUT: Duration = Duration::from_millis(1200);
 const BLOCKING_LIFECYCLE_TIMEOUT: Duration = Duration::from_millis(800);
 const BLOCKING_FIRST_PROMPT_TIMEOUT: Duration = Duration::from_millis(500);
 const TELEMETRY_SCHEMA_VERSION: u32 = 6;
 const DEFAULT_DISCOVERY_ENDPOINT: &str = "https://api.jcode.sh/v1/discovery";
+#[cfg_attr(test, allow(dead_code))]
 static TELEMETRY_PERMANENTLY_REJECTED: AtomicBool = AtomicBool::new(false);
+#[cfg_attr(test, allow(dead_code))]
 static TELEMETRY_QUEUE_OVERFLOW_WARNED: AtomicBool = AtomicBool::new(false);
+#[cfg_attr(test, allow(dead_code))]
 static TELEMETRY_BACKGROUND_SENDER: OnceLock<SyncSender<Value>> = OnceLock::new();
+#[cfg_attr(test, allow(dead_code))]
 static TRANSCRIPT_BACKGROUND_SENDER: OnceLock<SyncSender<Value>> = OnceLock::new();
+#[cfg_attr(test, allow(dead_code))]
 static TELEMETRY_HTTP_CLIENT: OnceLock<reqwest::blocking::Client> = OnceLock::new();
 #[cfg(test)]
 static TEST_EMITTED_PAYLOADS: Mutex<Vec<Value>> = Mutex::new(Vec::new());
@@ -1288,6 +1300,7 @@ pub fn record_command_family(command: &str) {
     maybe_emit_session_start();
 }
 
+#[cfg_attr(test, allow(dead_code))] // wired only in cfg(not(test)) delivery paths
 fn post_payload(payload: serde_json::Value, timeout: Duration) -> bool {
     if TELEMETRY_PERMANENTLY_REJECTED.load(Ordering::Relaxed) {
         return false;
@@ -1326,6 +1339,7 @@ fn post_payload(payload: serde_json::Value, timeout: Duration) -> bool {
     }
 }
 
+#[cfg_attr(test, allow(dead_code))] // wired only in cfg(not(test)) delivery paths
 fn post_payload_with_retry(payload: serde_json::Value, timeout: Duration) -> bool {
     const RETRY_DELAYS: [Duration; 2] = [Duration::from_millis(200), Duration::from_millis(800)];
     if post_payload(payload.clone(), timeout) {
@@ -1343,6 +1357,7 @@ fn post_payload_with_retry(payload: serde_json::Value, timeout: Duration) -> boo
     false
 }
 
+#[cfg_attr(test, allow(dead_code))] // wired only in cfg(not(test)) delivery paths
 fn post_transcript_payload(payload: serde_json::Value, timeout: Duration) -> bool {
     let client = TELEMETRY_HTTP_CLIENT.get_or_init(|| {
         reqwest::blocking::Client::builder()
@@ -1390,6 +1405,7 @@ where
     Ok(sender)
 }
 
+#[cfg_attr(test, allow(dead_code))] // wired only in cfg(not(test)) delivery paths
 fn background_sender() -> &'static SyncSender<Value> {
     TELEMETRY_BACKGROUND_SENDER.get_or_init(|| {
         spawn_background_worker(BACKGROUND_QUEUE_CAPACITY, |payload| {
@@ -1399,6 +1415,7 @@ fn background_sender() -> &'static SyncSender<Value> {
     })
 }
 
+#[cfg_attr(test, allow(dead_code))] // wired only in cfg(not(test)) delivery paths
 fn transcript_background_sender() -> &'static SyncSender<Value> {
     TRANSCRIPT_BACKGROUND_SENDER.get_or_init(|| {
         spawn_background_worker(64, |payload| {
@@ -1414,7 +1431,7 @@ fn send_transcript_payload(payload: Value) -> bool {
         if let Ok(mut emitted) = TEST_EMITTED_PAYLOADS.lock() {
             emitted.push(payload);
         }
-        return true;
+        true
     }
     #[cfg(not(test))]
     match transcript_background_sender().try_send(payload) {
@@ -1438,7 +1455,7 @@ fn send_payload(mut payload: serde_json::Value, mode: DeliveryMode) -> bool {
         if let Ok(mut emitted) = TEST_EMITTED_PAYLOADS.lock() {
             emitted.push(payload);
         }
-        return true;
+        true
     }
     #[cfg(not(test))]
     match mode {
diff --git a/crates/jcode-terminal-launch/src/lib.rs b/crates/jcode-terminal-launch/src/lib.rs
index 5b87db4ed1..38cb0b936e 100644
--- a/crates/jcode-terminal-launch/src/lib.rs
+++ b/crates/jcode-terminal-launch/src/lib.rs
@@ -266,11 +266,11 @@ fn detected_resume_terminal_with_client_env(
 
     #[cfg(target_os = "macos")]
     {
-        return match term_program.as_deref() {
+        match term_program.as_deref() {
             Some("iterm.app") | Some("iterm2") => Some("iterm2".to_string()),
             Some("apple_terminal") | Some("terminal") => Some("terminal".to_string()),
             _ => None,
-        };
+        }
     }
 
     #[cfg(not(target_os = "macos"))]
diff --git a/crates/jcode-transport/src/unix.rs b/crates/jcode-transport/src/unix.rs
index 9f6135599f..22b16fb49c 100644
--- a/crates/jcode-transport/src/unix.rs
+++ b/crates/jcode-transport/src/unix.rs
@@ -34,7 +34,7 @@ mod tests {
         let path = dir.join("round-trip.sock");
         remove_socket(&path);
 
-        let mut listener = Listener::bind(&path).expect("bind");
+        let listener = Listener::bind(&path).expect("bind");
         assert!(is_socket_path(&path), "a bound socket path should exist");
 
         let server = tokio::spawn(async move {
diff --git a/crates/jcode-tui-markdown/src/lib.rs b/crates/jcode-tui-markdown/src/lib.rs
index 87c2a4f542..ac93014261 100644
--- a/crates/jcode-tui-markdown/src/lib.rs
+++ b/crates/jcode-tui-markdown/src/lib.rs
@@ -107,8 +107,7 @@ pub(crate) use context::with_markdown_spacing_mode_override;
 pub use context::{
     center_code_blocks, get_diagram_mode_override, mermaid_rendering_enabled,
     set_center_code_blocks, set_diagram_mode_override, with_center_code_blocks,
-    with_deferred_mermaid_render_context,
-    with_diagram_mode_scope, with_mermaid_rendering_override,
+    with_deferred_mermaid_render_context, with_diagram_mode_scope, with_mermaid_rendering_override,
 };
 use context::{
     deferred_mermaid_render_context_enabled, effective_diagram_mode,
diff --git a/crates/jcode-tui-mermaid/src/lib.rs b/crates/jcode-tui-mermaid/src/lib.rs
index a0f02051d3..cbe5fe134c 100644
--- a/crates/jcode-tui-mermaid/src/lib.rs
+++ b/crates/jcode-tui-mermaid/src/lib.rs
@@ -438,7 +438,9 @@ static MERMAID_SOURCE_BY_HASH: LazyLock<Mutex<HashMap<u64, String>>> =
 static MERMAID_INLINE_EXPAND_LEVEL: LazyLock<Mutex<HashMap<u64, u8>>> =
     LazyLock::new(|| Mutex::new(HashMap::new()));
 static MERMAID_INLINE_EXPAND_EPOCH: AtomicU64 = AtomicU64::new(0);
-static MERMAID_INLINE_LEVEL_GEOMETRY: LazyLock<Mutex<HashMap<u64, [(u16, u16); 3]>>> =
+/// Per-level (rows, cols) geometry for each rendered inline diagram hash.
+type InlineLevelGeometry = HashMap<u64, [(u16, u16); 3]>;
+static MERMAID_INLINE_LEVEL_GEOMETRY: LazyLock<Mutex<InlineLevelGeometry>> =
     LazyLock::new(|| Mutex::new(HashMap::new()));
 
 pub fn mermaid_source_for_hash(hash: u64) -> Option<String> {
diff --git a/crates/jcode-tui-mermaid/src/mermaid_content.rs b/crates/jcode-tui-mermaid/src/mermaid_content.rs
index 5eb32f85d3..13e39cbd2a 100644
--- a/crates/jcode-tui-mermaid/src/mermaid_content.rs
+++ b/crates/jcode-tui-mermaid/src/mermaid_content.rs
@@ -297,81 +297,6 @@ fn result_to_lines_with_capabilities(
     }
 }
 
-#[cfg(test)]
-mod fallback_note_tests {
-    use super::*;
-
-    #[test]
-    fn fallback_note_explains_why_the_image_is_text() {
-        let text = text_image_fallback_note_line()
-            .spans
-            .iter()
-            .map(|span| span.content.as_ref())
-            .collect::<String>();
-        assert!(text.contains("terminal cannot render inline images"));
-        assert!(text.contains("text fallback"));
-    }
-
-    fn image_result() -> RenderResult {
-        RenderResult::Image {
-            hash: 0x1234,
-            path: PathBuf::from("test.png"),
-            width: 640,
-            height: 480,
-        }
-    }
-
-    #[test]
-    fn clicked_mermaid_expand_level_changes_placeholder_height() {
-        let hash = 0x9a11_ce55_u64;
-        let result = || RenderResult::Image {
-            hash,
-            path: PathBuf::from("diagram.png"),
-            width: 1500,
-            height: 1125,
-        };
-
-        crate::set_mermaid_inline_expand_level(hash, 0);
-        let fit = result_to_lines_with_capabilities(result(), Some(95), false, true, false);
-        crate::set_mermaid_inline_expand_level(hash, 1);
-        let large = result_to_lines_with_capabilities(result(), Some(95), false, true, false);
-        crate::set_mermaid_inline_expand_level(hash, 0);
-
-        assert!(
-            large.len() > fit.len(),
-            "click expansion must change Mermaid placeholder height: fit={}, large={}",
-            fit.len(),
-            large.len()
-        );
-    }
-
-    #[test]
-    fn halfblock_result_attaches_note_after_image_placeholder() {
-        let lines = result_to_lines_with_capabilities(image_result(), Some(80), false, true, true);
-        assert!(parse_inline_image_placeholder(&lines[0]).is_some());
-        let note = lines
-            .last()
-            .expect("fallback result should end with a note")
-            .spans
-            .iter()
-            .map(|span| span.content.as_ref())
-            .collect::<String>();
-        assert!(note.contains(TERMINAL_IMAGE_FALLBACK_NOTE));
-    }
-
-    #[test]
-    fn native_protocol_result_starts_with_image_placeholder_without_note() {
-        let lines = result_to_lines_with_capabilities(image_result(), Some(80), false, true, false);
-        assert!(parse_inline_image_placeholder(&lines[0]).is_some());
-        assert!(lines.iter().all(|line| {
-            !line
-                .spans
-                .iter()
-                .any(|span| span.content.contains(TERMINAL_IMAGE_FALLBACK_NOTE))
-        }));
-    }
-}
-
 /// Marker prefix for mermaid image placeholders
 const MERMAID_MARKER_PREFIX: &str = "\x00MERMAID_IMAGE:";
 const MERMAID_MARKER_SUFFIX: &str = "\x00";
@@ -656,3 +581,78 @@ pub fn terminal_theme() -> Theme {
         pie_opacity: 0.92,
     }
 }
+
+#[cfg(test)]
+mod fallback_note_tests {
+    use super::*;
+
+    #[test]
+    fn fallback_note_explains_why_the_image_is_text() {
+        let text = text_image_fallback_note_line()
+            .spans
+            .iter()
+            .map(|span| span.content.as_ref())
+            .collect::<String>();
+        assert!(text.contains("terminal cannot render inline images"));
+        assert!(text.contains("text fallback"));
+    }
+
+    fn image_result() -> RenderResult {
+        RenderResult::Image {
+            hash: 0x1234,
+            path: PathBuf::from("test.png"),
+            width: 640,
+            height: 480,
+        }
+    }
+
+    #[test]
+    fn clicked_mermaid_expand_level_changes_placeholder_height() {
+        let hash = 0x9a11_ce55_u64;
+        let result = || RenderResult::Image {
+            hash,
+            path: PathBuf::from("diagram.png"),
+            width: 1500,
+            height: 1125,
+        };
+
+        crate::set_mermaid_inline_expand_level(hash, 0);
+        let fit = result_to_lines_with_capabilities(result(), Some(95), false, true, false);
+        crate::set_mermaid_inline_expand_level(hash, 1);
+        let large = result_to_lines_with_capabilities(result(), Some(95), false, true, false);
+        crate::set_mermaid_inline_expand_level(hash, 0);
+
+        assert!(
+            large.len() > fit.len(),
+            "click expansion must change Mermaid placeholder height: fit={}, large={}",
+            fit.len(),
+            large.len()
+        );
+    }
+
+    #[test]
+    fn halfblock_result_attaches_note_after_image_placeholder() {
+        let lines = result_to_lines_with_capabilities(image_result(), Some(80), false, true, true);
+        assert!(parse_inline_image_placeholder(&lines[0]).is_some());
+        let note = lines
+            .last()
+            .expect("fallback result should end with a note")
+            .spans
+            .iter()
+            .map(|span| span.content.as_ref())
+            .collect::<String>();
+        assert!(note.contains(TERMINAL_IMAGE_FALLBACK_NOTE));
+    }
+
+    #[test]
+    fn native_protocol_result_starts_with_image_placeholder_without_note() {
+        let lines = result_to_lines_with_capabilities(image_result(), Some(80), false, true, false);
+        assert!(parse_inline_image_placeholder(&lines[0]).is_some());
+        assert!(lines.iter().all(|line| {
+            !line
+                .spans
+                .iter()
+                .any(|span| span.content.contains(TERMINAL_IMAGE_FALLBACK_NOTE))
+        }));
+    }
+}
diff --git a/crates/jcode-tui-mermaid/src/mermaid_tests/part_02.rs b/crates/jcode-tui-mermaid/src/mermaid_tests/part_02.rs
index eca001c9c9..643f9141a1 100644
--- a/crates/jcode-tui-mermaid/src/mermaid_tests/part_02.rs
+++ b/crates/jcode-tui-mermaid/src/mermaid_tests/part_02.rs
@@ -448,8 +448,7 @@ fn inline_transcript_aspect_goal_produces_expected_bucketed_profile() {
     assert_eq!(goal, Some(1.75));
 
     // The goal flows through the standard profile bucketing (per-mille).
-    let bucket =
-        crate::with_preferred_aspect_ratio(goal, || crate::current_preferred_aspect_ratio_bucket());
+    let bucket = crate::with_preferred_aspect_ratio(goal, crate::current_preferred_aspect_ratio_bucket);
     assert_eq!(bucket, Some(1750));
 
     // Narrow terminals floor at the 4:3 sizing default instead of requesting
diff --git a/crates/jcode-tui-mermaid/src/mermaid_viewport.rs b/crates/jcode-tui-mermaid/src/mermaid_viewport.rs
index f0c308d1a6..1f635be6b3 100644
--- a/crates/jcode-tui-mermaid/src/mermaid_viewport.rs
+++ b/crates/jcode-tui-mermaid/src/mermaid_viewport.rs
@@ -1822,7 +1822,7 @@ mod kitty_viewport_leak_tests {
             );
         }
         assert!(
-            SOURCE_CACHE.lock().unwrap().entries.get(&HASH).is_none(),
+            !SOURCE_CACHE.lock().unwrap().entries.contains_key(&HASH),
             "full decoded original should be released after fitting"
         );
         assert_eq!(
diff --git a/crates/jcode-tui-mermaid/tests/webui_protocol_gate.rs b/crates/jcode-tui-mermaid/tests/webui_protocol_gate.rs
index afad23c008..c39ce59b2e 100644
--- a/crates/jcode-tui-mermaid/tests/webui_protocol_gate.rs
+++ b/crates/jcode-tui-mermaid/tests/webui_protocol_gate.rs
@@ -86,4 +86,4 @@ fn herdr_webui_gate_picks_halfblocks_and_control_picks_kitty() {
 
     require_gate_child("webui", "Some(Halfblocks)");
     require_gate_child("control", "Some(Kitty)");
-}
\ No newline at end of file
+}
diff --git a/crates/jcode-tui-style/src/theme_mode.rs b/crates/jcode-tui-style/src/theme_mode.rs
index e0fec60f3c..5b6ab74219 100644
--- a/crates/jcode-tui-style/src/theme_mode.rs
+++ b/crates/jcode-tui-style/src/theme_mode.rs
@@ -252,10 +252,10 @@ pub fn adapt_buffer_for_display(buf: &mut Buffer) {
 
 /// The same ordering for a foreground patched outside a full-frame redraw.
 pub fn adapt_foreground_for_display(color: Color, background: Color) -> Color {
-    if let Some(palette) = crate::palette::configured_palette() {
-        if let Some(chosen) = crate::palette::configured_native_color(&palette, color) {
-            return chosen;
-        }
+    if let Some(palette) = crate::palette::configured_palette()
+        && let Some(chosen) = crate::palette::configured_native_color(&palette, color)
+    {
+        return chosen;
     }
     adapt_foreground_for_theme(color, background)
 }
diff --git a/crates/jcode-tui/src/tui/app/auth_account_picker_saved_accounts.rs b/crates/jcode-tui/src/tui/app/auth_account_picker_saved_accounts.rs
index 7264747b47..5d813c7ea9 100644
--- a/crates/jcode-tui/src/tui/app/auth_account_picker_saved_accounts.rs
+++ b/crates/jcode-tui/src/tui/app/auth_account_picker_saved_accounts.rs
@@ -309,31 +309,6 @@ pub(super) fn anthropic_account_use(subscription_type: Option<&str>) -> &'static
     }
 }
 
-#[cfg(test)]
-mod account_display_tests {
-    use super::*;
-
-    #[test]
-    fn animals_only_distinguish_duplicate_provider_logins() {
-        assert_eq!(account_display_name("Claude", "claude-otter", 1), "Claude");
-        assert_eq!(
-            account_display_name("Claude", "claude-otter", 2),
-            "Claude Otter"
-        );
-        assert_eq!(
-            account_display_name("Claude", "claude-fox", 2),
-            "Claude Fox"
-        );
-    }
-
-    #[test]
-    fn known_anthropic_plans_identify_personal_and_work_accounts() {
-        assert_eq!(anthropic_account_use(Some("max")), "personal");
-        assert_eq!(anthropic_account_use(Some("team")), "work");
-        assert_eq!(anthropic_account_use(None), "unknown");
-    }
-}
-
 fn format_account_table(headers: &[&str; 5], rows: &[[String; 5]]) -> Vec<String> {
     let mut widths = [0usize; 5];
     for (i, h) in headers.iter().enumerate() {
@@ -362,3 +337,28 @@ fn format_account_table(headers: &[&str; 5], rows: &[[String; 5]]) -> Vec<String
     }
     lines
 }
+
+#[cfg(test)]
+mod account_display_tests {
+    use super::*;
+
+    #[test]
+    fn animals_only_distinguish_duplicate_provider_logins() {
+        assert_eq!(account_display_name("Claude", "claude-otter", 1), "Claude");
+        assert_eq!(
+            account_display_name("Claude", "claude-otter", 2),
+            "Claude Otter"
+        );
+        assert_eq!(
+            account_display_name("Claude", "claude-fox", 2),
+            "Claude Fox"
+        );
+    }
+
+    #[test]
+    fn known_anthropic_plans_identify_personal_and_work_accounts() {
+        assert_eq!(anthropic_account_use(Some("max")), "personal");
+        assert_eq!(anthropic_account_use(Some("team")), "work");
+        assert_eq!(anthropic_account_use(None), "unknown");
+    }
+}
diff --git a/crates/jcode-tui/src/tui/app/auth_remote.rs b/crates/jcode-tui/src/tui/app/auth_remote.rs
index 4dfda9c554..f900d6012b 100644
--- a/crates/jcode-tui/src/tui/app/auth_remote.rs
+++ b/crates/jcode-tui/src/tui/app/auth_remote.rs
@@ -375,10 +375,10 @@ impl App {
             if code == KeyCode::Char('v')
                 && modifiers.intersects(KeyModifiers::CONTROL | KeyModifiers::SUPER)
             {
-                if let Ok(mut clipboard) = arboard::Clipboard::new() {
-                    if let Ok(text) = clipboard.get_text() {
-                        self.append_ssh_login_input(&text);
-                    }
+                if let Ok(mut clipboard) = arboard::Clipboard::new()
+                    && let Ok(text) = clipboard.get_text()
+                {
+                    self.append_ssh_login_input(&text);
                 }
                 return true;
             }
@@ -413,10 +413,10 @@ impl App {
                     || modifiers.contains(KeyModifiers::SUPER) =>
             {
                 // Explicit text clipboard paste only. Never invoke smart file/image paste.
-                if let Ok(mut clipboard) = arboard::Clipboard::new() {
-                    if let Ok(text) = clipboard.get_text() {
-                        self.append_ssh_login_input(&text);
-                    }
+                if let Ok(mut clipboard) = arboard::Clipboard::new()
+                    && let Ok(text) = clipboard.get_text()
+                {
+                    self.append_ssh_login_input(&text);
                 }
             }
             KeyCode::Backspace => {
diff --git a/crates/jcode-tui/src/tui/app/auth_remote/onboarding.rs b/crates/jcode-tui/src/tui/app/auth_remote/onboarding.rs
index 12f4ca20b7..a4c434cf69 100644
--- a/crates/jcode-tui/src/tui/app/auth_remote/onboarding.rs
+++ b/crates/jcode-tui/src/tui/app/auth_remote/onboarding.rs
@@ -10,168 +10,6 @@ pub(in crate::tui::app) struct Onboarding {
     task: Option<Task>,
 }
 
-#[cfg(test)]
-mod tests {
-    use super::super::command::ProviderStatus;
-    use super::super::tests::with_app;
-    use super::*;
-    use crossterm::event::{KeyCode, KeyModifiers};
-
-    fn empty_status() -> Vec<ProviderStatus> {
-        crate::provider_catalog::auth_status_login_providers()
-            .into_iter()
-            .map(|p| ProviderStatus {
-                id: p.id.into(),
-                state: crate::auth::AuthState::NotConfigured,
-                method_detail: "not configured".into(),
-            })
-            .collect()
-    }
-
-    fn queue_empty_status(app: &mut App) {
-        app.remote_login_onboarding = Onboarding {
-            checked: false,
-            task: Some(Task::ready(Ok(Reply::Status {
-                providers: empty_status(),
-            }))),
-        };
-    }
-
-    #[test]
-    fn ssh_onboarding_requires_complete_empty_status_including_api_keys() {
-        assert!(remote_has_no_logins(&empty_status()));
-        assert!(!remote_has_no_logins(&[]));
-        let mut partial = empty_status();
-        partial.pop();
-        assert!(!remote_has_no_logins(&partial));
-        for index in 0..empty_status().len() {
-            for state in [
-                crate::auth::AuthState::Available,
-                crate::auth::AuthState::Expired,
-            ] {
-                let mut statuses = empty_status();
-                statuses[index].state = state;
-                assert!(!remote_has_no_logins(&statuses), "{}", statuses[index].id);
-            }
-        }
-    }
-
-    #[test]
-    fn ssh_onboarding_offers_once_and_no_opens_normal_login_without_copying() {
-        with_app(|app| {
-            queue_empty_status(app);
-            assert!(app.poll_ssh_login_onboarding());
-            assert!(app.remote_login.as_ref().unwrap().phase == Phase::ImportOffer);
-            assert!(app.remote_login.as_ref().unwrap().task.is_none());
-            assert!(
-                app.display_messages()
-                    .last()
-                    .unwrap()
-                    .content
-                    .contains("No logins are configured on test-remote")
-            );
-            let picker = app.inline_interactive_state.as_ref().unwrap();
-            assert_eq!(picker.entries[picker.selected].name, "No");
-            app.handle_ssh_login_key(KeyCode::Enter, KeyModifiers::NONE, None);
-            assert!(app.remote_login.as_ref().unwrap().phase == Phase::Choosing);
-            assert!(app.inline_interactive_state.as_ref().unwrap().entries.len() > 2);
-            app.cancel_ssh_login();
-            assert!(!app.poll_ssh_login_onboarding());
-            assert!(app.remote_login.is_none());
-            assert!(app.pasted_contents.is_empty());
-            assert!(app.queued_messages.is_empty());
-        });
-    }
-
-    #[test]
-    fn ssh_onboarding_yes_chooses_provider_then_requires_separate_copy_consent() {
-        with_app(|app| {
-            queue_empty_status(app);
-            assert!(app.poll_ssh_login_onboarding());
-            app.handle_ssh_login_key(KeyCode::Up, KeyModifiers::NONE, None);
-            app.handle_ssh_login_key(KeyCode::Enter, KeyModifiers::NONE, None);
-            assert_eq!(
-                app.inline_interactive_state.as_ref().unwrap().entries.len(),
-                2
-            );
-            assert!(app.remote_login.as_ref().unwrap().task.is_none());
-            app.handle_ssh_login_key(KeyCode::Enter, KeyModifiers::NONE, None);
-            assert!(app.remote_login.as_ref().unwrap().phase == Phase::ImportConsent);
-            assert_eq!(app.remote_login.as_ref().unwrap().provider, "openai");
-            assert!(app.remote_login.as_ref().unwrap().task.is_none());
-            // Default No is conservative even after Yes to the initial offer.
-            app.handle_ssh_login_key(KeyCode::Enter, KeyModifiers::NONE, None);
-            assert!(app.remote_login.is_none());
-            assert!(
-                app.display_messages()
-                    .last()
-                    .unwrap()
-                    .content
-                    .contains("No local credentials were read or copied")
-            );
-        });
-    }
-
-    #[test]
-    fn ssh_onboarding_pasted_yes_and_no_stay_private() {
-        with_app(|app| {
-            queue_empty_status(app);
-            assert!(app.poll_ssh_login_onboarding());
-            app.handle_paste("yes".into());
-            assert_eq!(app.input, "[hidden login input]");
-            assert!(app.pasted_contents.is_empty());
-            app.handle_ssh_login_key(KeyCode::Enter, KeyModifiers::NONE, None);
-            assert_eq!(
-                app.inline_interactive_state.as_ref().unwrap().entries.len(),
-                2
-            );
-            app.handle_ssh_login_key(KeyCode::Enter, KeyModifiers::NONE, None);
-            app.handle_paste("no".into());
-            app.handle_ssh_login_key(KeyCode::Enter, KeyModifiers::NONE, None);
-            assert!(app.remote_login.is_none());
-            assert!(app.input.is_empty());
-        });
-    }
-
-    #[test]
-    fn ssh_onboarding_never_replaces_drafts_or_explicit_login() {
-        with_app(|app| {
-            queue_empty_status(app);
-            app.input = "unfinished draft".into();
-            assert!(!app.poll_ssh_login_onboarding());
-            assert_eq!(app.input, "unfinished draft");
-            assert!(app.remote_login.is_none());
-            app.input.clear();
-            app.pending_turn = true;
-            assert!(!app.poll_ssh_login_onboarding());
-            app.pending_turn = false;
-            app.handle_ssh_login_command("/login");
-            assert!(app.remote_login_onboarding.task.is_none());
-            app.cancel_ssh_login();
-            assert!(!app.poll_ssh_login_onboarding());
-        });
-    }
-
-    #[test]
-    fn ssh_onboarding_unknown_status_never_claims_signed_out_or_retries() {
-        with_app(|app| {
-            for reply in [
-                Err("status failed"),
-                Ok(Reply::Status { providers: vec![] }),
-            ] {
-                app.remote_login_onboarding = Onboarding {
-                    checked: false,
-                    task: Some(Task::ready(reply)),
-                };
-                assert!(!app.poll_ssh_login_onboarding());
-                assert!(app.remote_login_onboarding.checked);
-                assert!(app.remote_login.is_none());
-                assert!(!app.poll_ssh_login_onboarding());
-            }
-        });
-    }
-}
-
 impl Onboarding {
     pub(super) fn dismiss(&mut self) {
         self.checked = true;
@@ -345,3 +183,165 @@ impl App {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::super::command::ProviderStatus;
+    use super::super::tests::with_app;
+    use super::*;
+    use crossterm::event::{KeyCode, KeyModifiers};
+
+    fn empty_status() -> Vec<ProviderStatus> {
+        crate::provider_catalog::auth_status_login_providers()
+            .into_iter()
+            .map(|p| ProviderStatus {
+                id: p.id.into(),
+                state: crate::auth::AuthState::NotConfigured,
+                method_detail: "not configured".into(),
+            })
+            .collect()
+    }
+
+    fn queue_empty_status(app: &mut App) {
+        app.remote_login_onboarding = Onboarding {
+            checked: false,
+            task: Some(Task::ready(Ok(Reply::Status {
+                providers: empty_status(),
+            }))),
+        };
+    }
+
+    #[test]
+    fn ssh_onboarding_requires_complete_empty_status_including_api_keys() {
+        assert!(remote_has_no_logins(&empty_status()));
+        assert!(!remote_has_no_logins(&[]));
+        let mut partial = empty_status();
+        partial.pop();
+        assert!(!remote_has_no_logins(&partial));
+        for index in 0..empty_status().len() {
+            for state in [
+                crate::auth::AuthState::Available,
+                crate::auth::AuthState::Expired,
+            ] {
+                let mut statuses = empty_status();
+                statuses[index].state = state;
+                assert!(!remote_has_no_logins(&statuses), "{}", statuses[index].id);
+            }
+        }
+    }
+
+    #[test]
+    fn ssh_onboarding_offers_once_and_no_opens_normal_login_without_copying() {
+        with_app(|app| {
+            queue_empty_status(app);
+            assert!(app.poll_ssh_login_onboarding());
+            assert!(app.remote_login.as_ref().unwrap().phase == Phase::ImportOffer);
+            assert!(app.remote_login.as_ref().unwrap().task.is_none());
+            assert!(
+                app.display_messages()
+                    .last()
+                    .unwrap()
+                    .content
+                    .contains("No logins are configured on test-remote")
+            );
+            let picker = app.inline_interactive_state.as_ref().unwrap();
+            assert_eq!(picker.entries[picker.selected].name, "No");
+            app.handle_ssh_login_key(KeyCode::Enter, KeyModifiers::NONE, None);
+            assert!(app.remote_login.as_ref().unwrap().phase == Phase::Choosing);
+            assert!(app.inline_interactive_state.as_ref().unwrap().entries.len() > 2);
+            app.cancel_ssh_login();
+            assert!(!app.poll_ssh_login_onboarding());
+            assert!(app.remote_login.is_none());
+            assert!(app.pasted_contents.is_empty());
+            assert!(app.queued_messages.is_empty());
+        });
+    }
+
+    #[test]
+    fn ssh_onboarding_yes_chooses_provider_then_requires_separate_copy_consent() {
+        with_app(|app| {
+            queue_empty_status(app);
+            assert!(app.poll_ssh_login_onboarding());
+            app.handle_ssh_login_key(KeyCode::Up, KeyModifiers::NONE, None);
+            app.handle_ssh_login_key(KeyCode::Enter, KeyModifiers::NONE, None);
+            assert_eq!(
+                app.inline_interactive_state.as_ref().unwrap().entries.len(),
+                2
+            );
+            assert!(app.remote_login.as_ref().unwrap().task.is_none());
+            app.handle_ssh_login_key(KeyCode::Enter, KeyModifiers::NONE, None);
+            assert!(app.remote_login.as_ref().unwrap().phase == Phase::ImportConsent);
+            assert_eq!(app.remote_login.as_ref().unwrap().provider, "openai");
+            assert!(app.remote_login.as_ref().unwrap().task.is_none());
+            // Default No is conservative even after Yes to the initial offer.
+            app.handle_ssh_login_key(KeyCode::Enter, KeyModifiers::NONE, None);
+            assert!(app.remote_login.is_none());
+            assert!(
+                app.display_messages()
+                    .last()
+                    .unwrap()
+                    .content
+                    .contains("No local credentials were read or copied")
+            );
+        });
+    }
+
+    #[test]
+    fn ssh_onboarding_pasted_yes_and_no_stay_private() {
+        with_app(|app| {
+            queue_empty_status(app);
+            assert!(app.poll_ssh_login_onboarding());
+            app.handle_paste("yes".into());
+            assert_eq!(app.input, "[hidden login input]");
+            assert!(app.pasted_contents.is_empty());
+            app.handle_ssh_login_key(KeyCode::Enter, KeyModifiers::NONE, None);
+            assert_eq!(
+                app.inline_interactive_state.as_ref().unwrap().entries.len(),
+                2
+            );
+            app.handle_ssh_login_key(KeyCode::Enter, KeyModifiers::NONE, None);
+            app.handle_paste("no".into());
+            app.handle_ssh_login_key(KeyCode::Enter, KeyModifiers::NONE, None);
+            assert!(app.remote_login.is_none());
+            assert!(app.input.is_empty());
+        });
+    }
+
+    #[test]
+    fn ssh_onboarding_never_replaces_drafts_or_explicit_login() {
+        with_app(|app| {
+            queue_empty_status(app);
+            app.input = "unfinished draft".into();
+            assert!(!app.poll_ssh_login_onboarding());
+            assert_eq!(app.input, "unfinished draft");
+            assert!(app.remote_login.is_none());
+            app.input.clear();
+            app.pending_turn = true;
+            assert!(!app.poll_ssh_login_onboarding());
+            app.pending_turn = false;
+            app.handle_ssh_login_command("/login");
+            assert!(app.remote_login_onboarding.task.is_none());
+            app.cancel_ssh_login();
+            assert!(!app.poll_ssh_login_onboarding());
+        });
+    }
+
+    #[test]
+    fn ssh_onboarding_unknown_status_never_claims_signed_out_or_retries() {
+        with_app(|app| {
+            for reply in [
+                Err("status failed"),
+                Ok(Reply::Status { providers: vec![] }),
+            ] {
+                app.remote_login_onboarding = Onboarding {
+                    checked: false,
+                    task: Some(Task::ready(reply)),
+                };
+                assert!(!app.poll_ssh_login_onboarding());
+                assert!(app.remote_login_onboarding.checked);
+                assert!(app.remote_login.is_none());
+                assert!(!app.poll_ssh_login_onboarding());
+            }
+        });
+    }
+}
diff --git a/crates/jcode-tui/src/tui/app/helpers.rs b/crates/jcode-tui/src/tui/app/helpers.rs
index e128bb01d9..61f7c370b1 100644
--- a/crates/jcode-tui/src/tui/app/helpers.rs
+++ b/crates/jcode-tui/src/tui/app/helpers.rs
@@ -404,7 +404,7 @@ pub(super) fn copy_to_clipboard(text: &str) -> bool {
                 None => *sink = Some(text.to_string()),
             }
         }
-        return true;
+        true
     }
 
     #[cfg(not(test))]
@@ -454,7 +454,7 @@ pub(super) fn copy_to_clipboard(text: &str) -> bool {
                     }
                 }
             }
-            return copy_to_clipboard_osc52(text);
+            copy_to_clipboard_osc52(text)
         }
 
         // Linux has the same failure class (issue #504, Kali/X11): wl-copy fails
@@ -505,6 +505,9 @@ pub(super) fn copy_to_clipboard(text: &str) -> bool {
 /// terminal emulator to set the system clipboard without needing a local
 /// display server, making it work over SSH, inside Docker, and under tmux
 /// (with `set -g set-clipboard on`). Returns false if stdout is not a TTY.
+// Only reachable through cfg(not(test)) callers; the test build stubs the
+// clipboard, so the fn looks dead there.
+#[cfg_attr(test, allow(dead_code))]
 fn copy_to_clipboard_osc52(text: &str) -> bool {
     use base64::Engine as _;
     use std::io::{IsTerminal, Write};
@@ -911,13 +914,13 @@ pub(super) fn clipboard_image() -> Option<(String, String)> {
             .output()
         {
             let result = String::from_utf8_lossy(&output.stdout).trim().to_string();
-            if result == "ok" {
-                if let Ok(data) = std::fs::read(&temp_path) {
-                    let _ = std::fs::remove_file(&temp_path);
-                    if !data.is_empty() {
-                        let b64 = base64::engine::general_purpose::STANDARD.encode(&data);
-                        return Some(("image/png".to_string(), b64));
-                    }
+            if result == "ok"
+                && let Ok(data) = std::fs::read(&temp_path)
+            {
+                let _ = std::fs::remove_file(&temp_path);
+                if !data.is_empty() {
+                    let b64 = base64::engine::general_purpose::STANDARD.encode(&data);
+                    return Some(("image/png".to_string(), b64));
                 }
             }
         }
diff --git a/crates/jcode-tui/src/tui/app/remote/server_events.rs b/crates/jcode-tui/src/tui/app/remote/server_events.rs
index 59134b5e7a..3eb2ed6651 100644
--- a/crates/jcode-tui/src/tui/app/remote/server_events.rs
+++ b/crates/jcode-tui/src/tui/app/remote/server_events.rs
@@ -2300,8 +2300,10 @@ pub(in crate::tui::app) fn handle_server_event(
         }
         ServerEvent::ModelUsageUpdated { route } => {
             for cached in &mut app.remote_model_options {
-                if cached.model == route.model && cached.provider == route.provider
-                    && cached.api_method == route.api_method {
+                if cached.model == route.model
+                    && cached.provider == route.provider
+                    && cached.api_method == route.api_method
+                {
                     cached.usage = route.usage.clone();
                 }
             }
diff --git a/crates/jcode-tui/src/tui/app/tests/ssh_remote.rs b/crates/jcode-tui/src/tui/app/tests/ssh_remote.rs
index a130e0e88c..b518ec8b8c 100644
--- a/crates/jcode-tui/src/tui/app/tests/ssh_remote.rs
+++ b/crates/jcode-tui/src/tui/app/tests/ssh_remote.rs
@@ -121,9 +121,11 @@ fn ssh_remote_reconnect_waits_for_authoritative_history_without_local_reload() {
         let runtime = tokio::runtime::Runtime::new().unwrap();
         runtime.block_on(async {
             let mut remote = crate::tui::backend::RemoteConnection::dummy();
-            let mut state = super::remote::RemoteRunState::default();
-            state.reconnect_attempts = 1;
-            state.server_reload_in_progress = true;
+            let mut state = super::remote::RemoteRunState {
+                reconnect_attempts: 1,
+                server_reload_in_progress: true,
+                ..Default::default()
+            };
             assert!(!super::remote::reload_handoff_active(&state));
             let mut terminal =
                 ratatui::Terminal::new(ratatui::backend::TestBackend::new(80, 24)).unwrap();
diff --git a/crates/jcode-tui/src/tui/backend.rs b/crates/jcode-tui/src/tui/backend.rs
index d13b6c9233..e7966aae16 100644
--- a/crates/jcode-tui/src/tui/backend.rs
+++ b/crates/jcode-tui/src/tui/backend.rs
@@ -660,7 +660,11 @@ impl RemoteConnection {
     pub async fn request_model_catalog(&mut self) -> Result<u64> {
         let id = self.next_request_id;
         self.next_request_id += 1;
-        self.send_request(Request::GetModelCatalog { id, subscribe_usage_updates: true }).await?;
+        self.send_request(Request::GetModelCatalog {
+            id,
+            subscribe_usage_updates: true,
+        })
+        .await?;
         Ok(id)
     }
 
diff --git a/crates/jcode-tui/src/tui/session_picker/loading_tests.rs b/crates/jcode-tui/src/tui/session_picker/loading_tests.rs
index 96b7a98516..d75be1bc29 100644
--- a/crates/jcode-tui/src/tui/session_picker/loading_tests.rs
+++ b/crates/jcode-tui/src/tui/session_picker/loading_tests.rs
@@ -862,11 +862,10 @@ fn jcode_search_index_keeps_late_turns_after_reaching_its_budget() {
 fn raw_search_excerpt_samples_suffix_of_one_long_message_without_splitting_utf8() {
     let prefix = "opening-message-needle";
     let suffix = "晚い-message-needle";
-    let raw: Box<serde_json::value::RawValue> = serde_json::from_str(&format!(
-        "{}",
-        serde_json::to_string(&format!("{prefix} {} {suffix}", "─".repeat(6_000)))
-            .expect("serialize content")
-    ))
+    let raw: Box<serde_json::value::RawValue> = serde_json::from_str(
+        &serde_json::to_string(&format!("{prefix} {} {suffix}", "─".repeat(6_000)))
+            .expect("serialize content"),
+    )
     .expect("raw value");
 
     let excerpt =
diff --git a/crates/jcode-tui/src/tui/ui_messages.rs b/crates/jcode-tui/src/tui/ui_messages.rs
index c13773000a..d455ce4f8d 100644
--- a/crates/jcode-tui/src/tui/ui_messages.rs
+++ b/crates/jcode-tui/src/tui/ui_messages.rs
@@ -1651,13 +1651,13 @@ fn render_todo_plan_update(
             .as_ref()
             .and_then(|plan| plan.understands_user_intent),
     );
-    if !update
+    if !(update
         .fields
         .contains(&crate::todo::TodoPlanField::UnderstandsUserIntent)
-        && !(intent_is_unclear
+        || (intent_is_unclear
             && update
                 .fields
-                .contains(&crate::todo::TodoPlanField::UserIntention))
+                .contains(&crate::todo::TodoPlanField::UserIntention)))
     {
         return Vec::new();
     }
diff --git a/crates/jcode-tui/src/tui/ui_tests/palette_topology.rs b/crates/jcode-tui/src/tui/ui_tests/palette_topology.rs
index fb598675dc..1aeba3f098 100644
--- a/crates/jcode-tui/src/tui/ui_tests/palette_topology.rs
+++ b/crates/jcode-tui/src/tui/ui_tests/palette_topology.rs
@@ -15,10 +15,10 @@ use ratatui::style::Color;
 use std::collections::BTreeMap;
 
 /// Render a set of representative frames and tally role area plus adjacency.
-fn measure() -> (
-    BTreeMap<&'static str, u32>,
-    BTreeMap<(&'static str, &'static str), u32>,
-) {
+type RoleArea = BTreeMap<&'static str, u32>;
+type RoleAdjacency = BTreeMap<(&'static str, &'static str), u32>;
+
+fn measure() -> (RoleArea, RoleAdjacency) {
     let _lock = super::viewport_snapshot_test_lock();
     // Attribution matches rendered RGB back to role defaults, so the frame
     // must be rendered in truecolor. A hosted CI runner without COLORTERM
diff --git a/src/cli/acp.rs b/src/cli/acp.rs
index d5363bc747..0e259cae93 100644
--- a/src/cli/acp.rs
+++ b/src/cli/acp.rs
@@ -1273,7 +1273,12 @@ async fn request_history(session: &DaemonSession) -> Result<ServerEvent> {
 
 async fn request_model_catalog(session: &DaemonSession) -> Result<ServerEvent> {
     let id = session.next_id();
-    session.send(&Request::GetModelCatalog { id, subscribe_usage_updates: false }).await?;
+    session
+        .send(&Request::GetModelCatalog {
+            id,
+            subscribe_usage_updates: false,
+        })
+        .await?;
     loop {
         match session.read_event().await? {
             ServerEvent::Ack { .. } => {}
diff --git a/src/cli/commands/menubar.rs b/src/cli/commands/menubar.rs
index 7812ca2c7a..a2e9181c00 100644
--- a/src/cli/commands/menubar.rs
+++ b/src/cli/commands/menubar.rs
@@ -169,12 +169,11 @@ pub fn ensure_menubar_helper_running() {
     let pid_path = dir.join("menubar.pid");
 
     // If a recorded helper PID is still alive, do nothing.
-    if let Ok(raw) = std::fs::read_to_string(&pid_path) {
-        if let Ok(pid) = raw.trim().parse::<u32>() {
-            if crate::platform::is_process_running(pid) {
-                return;
-            }
-        }
+    if let Ok(raw) = std::fs::read_to_string(&pid_path)
+        && let Ok(pid) = raw.trim().parse::<u32>()
+        && crate::platform::is_process_running(pid)
+    {
+        return;
     }
 
     let Ok(exe) = std::env::current_exe() else {
diff --git a/src/cli/commands_tests.rs b/src/cli/commands_tests.rs
index b2c9a286a3..bd99fb0ca8 100644
--- a/src/cli/commands_tests.rs
+++ b/src/cli/commands_tests.rs
@@ -291,6 +291,7 @@ fn collect_cli_model_names_prefers_available_routes_and_dedupes() {
             available: true,
             detail: String::new(),
             cheapness: None,
+            usage: None,
         },
         ModelRoute {
             model: "gpt-5.4".to_string(),
@@ -299,6 +300,7 @@ fn collect_cli_model_names_prefers_available_routes_and_dedupes() {
             available: true,
             detail: String::new(),
             cheapness: None,
+            usage: None,
         },
         ModelRoute {
             model: "openrouter models".to_string(),
@@ -307,6 +309,7 @@ fn collect_cli_model_names_prefers_available_routes_and_dedupes() {
             available: false,
             detail: "OPENROUTER_API_KEY not set".to_string(),
             cheapness: None,
+            usage: None,
         },
     ];
 
@@ -326,6 +329,7 @@ fn test_route(model: &str, provider: &str, api_method: &str) -> ModelRoute {
         available: true,
         detail: String::new(),
         cheapness: None,
+        usage: None,
     }
 }
 
@@ -1321,6 +1325,7 @@ fn collect_cli_model_names_falls_back_when_no_routes_are_available() {
         available: false,
         detail: "no credentials".to_string(),
         cheapness: None,
+        usage: None,
     }];
 
     let models = collect_cli_model_names(&routes, vec!["gpt-5.4".to_string()]);
diff --git a/src/cli/login/scriptable.rs b/src/cli/login/scriptable.rs
index edb95d142f..935d5d8571 100644
--- a/src/cli/login/scriptable.rs
+++ b/src/cli/login/scriptable.rs
@@ -862,6 +862,9 @@ pub(super) fn resolve_auth_input(value: &str) -> Result<String> {
     Ok(trimmed.to_string())
 }
 
+// One flat struct-free parameter list mirrors the CLI flag surface this
+// prompt renders; grouping into a struct would just move the same fields.
+#[allow(clippy::too_many_arguments)]
 pub(super) fn emit_scriptable_auth_prompt(
     provider: &str,
     auth_url: &str,
diff --git a/src/cli/login/tests.rs b/src/cli/login/tests.rs
index 24fce2dca1..bb64f50318 100644
--- a/src/cli/login/tests.rs
+++ b/src/cli/login/tests.rs
@@ -237,6 +237,7 @@ impl Drop for ScopedLoginTestHome {
     }
 }
 
+#[allow(clippy::await_holding_lock)] // env guard held across async body
 #[tokio::test]
 async fn scoped_concurrent_begin_completion_and_cancel_are_isolated() {
     let _guard = crate::storage::lock_test_env();
diff --git a/src/cli/macos_notification_broker.rs b/src/cli/macos_notification_broker.rs
index 5cd6764b9c..08aa8e0a03 100644
--- a/src/cli/macos_notification_broker.rs
+++ b/src/cli/macos_notification_broker.rs
@@ -151,7 +151,9 @@ mod platform {
             match authorization.load(Ordering::Acquire) {
                 AUTHORIZATION_GRANTED => drain_inbox(&center),
                 AUTHORIZATION_DENIED
-                    if ticks.fetch_add(1, Ordering::Relaxed) % AUTHORIZATION_RETRY_TICKS == 0 =>
+                    if ticks
+                        .fetch_add(1, Ordering::Relaxed)
+                        .is_multiple_of(AUTHORIZATION_RETRY_TICKS) =>
                 {
                     // Permission may be enabled while the helper is running.
                     // Re-query without dropping queued work; macOS only presents

From 1e41bac3eeb1044db8f8c8c46e4a0377232284d2 Mon Sep 17 00:00:00 2001
From: Alejandro Blanco-M <alecuba16@gmail.com>
Date: Sat, 19 Sep 2026 11:06:53 +0200
Subject: [PATCH 04/21] test: refresh stale guardrail baselines

Upstream master drifted past the committed ratchet baselines (they fail
on upstream/master itself, e.g. code-size turn_loops.rs 1260->1281,
panic 77->143, swallowed-error 3248->3373). Refresh all four baselines
at this branch's HEAD per the established 'test: refresh stale
baselines' precedent so the ratchets gate forward progress again.
---
 scripts/code_size_budget.json       | 168 +++++++++---------
 scripts/panic_budget.json           |  29 ++-
 scripts/swallowed_error_budget.json | 262 ++++++++++++++++++++--------
 scripts/test_size_budget.json       |  68 ++++----
 4 files changed, 340 insertions(+), 187 deletions(-)

diff --git a/scripts/code_size_budget.json b/scripts/code_size_budget.json
index db55e8fd37..0ca5948efe 100644
--- a/scripts/code_size_budget.json
+++ b/scripts/code_size_budget.json
@@ -1,110 +1,112 @@
 {
   "threshold_loc": 1200,
   "tracked_files": {
-    "crates/jcode-app-core/src/agent/turn_loops.rs": 1260,
-    "crates/jcode-app-core/src/agent/turn_streaming_mpsc.rs": 1730,
+    "crates/jcode-app-core/src/agent/turn_loops.rs": 1286,
+    "crates/jcode-app-core/src/agent/turn_streaming_mpsc.rs": 1752,
     "crates/jcode-app-core/src/overnight.rs": 1275,
-    "crates/jcode-app-core/src/server.rs": 2376,
-    "crates/jcode-app-core/src/server/client_lifecycle.rs": 3282,
-    "crates/jcode-app-core/src/server/client_session.rs": 1714,
+    "crates/jcode-app-core/src/server.rs": 2430,
+    "crates/jcode-app-core/src/server/client_lifecycle.rs": 3624,
+    "crates/jcode-app-core/src/server/client_session.rs": 1750,
     "crates/jcode-app-core/src/server/comm_control.rs": 2625,
-    "crates/jcode-app-core/src/server/comm_session.rs": 1434,
+    "crates/jcode-app-core/src/server/comm_session.rs": 1451,
     "crates/jcode-app-core/src/server/debug_server_state.rs": 1257,
     "crates/jcode-app-core/src/server/jade_relay.rs": 1429,
-    "crates/jcode-app-core/src/server/provider_control.rs": 1600,
+    "crates/jcode-app-core/src/server/provider_control.rs": 1612,
     "crates/jcode-app-core/src/server/swarm.rs": 3170,
-    "crates/jcode-app-core/src/tool/bash.rs": 1321,
-    "crates/jcode-app-core/src/tool/communicate.rs": 3351,
-    "crates/jcode-app-core/src/tool/discover.rs": 2418,
-    "crates/jcode-app-core/src/tool/mod.rs": 1230,
-    "crates/jcode-app-core/src/tool/selfdev/build_queue.rs": 1279,
+    "crates/jcode-app-core/src/tool/bash.rs": 1483,
+    "crates/jcode-app-core/src/tool/communicate.rs": 3364,
+    "crates/jcode-app-core/src/tool/discover.rs": 2982,
+    "crates/jcode-app-core/src/tool/mod.rs": 1446,
     "crates/jcode-app-core/src/tool/session_search.rs": 1892,
-    "crates/jcode-app-core/src/tool/todo.rs": 2472,
-    "crates/jcode-app-core/src/update.rs": 1717,
-    "crates/jcode-base/src/auth/lifecycle.rs": 2593,
-    "crates/jcode-base/src/auth/mod.rs": 1615,
-    "crates/jcode-base/src/auth/oauth.rs": 1518,
-    "crates/jcode-base/src/background.rs": 1465,
+    "crates/jcode-app-core/src/tool/todo.rs": 2528,
+    "crates/jcode-app-core/src/update.rs": 1771,
+    "crates/jcode-base/src/auth/lifecycle.rs": 2717,
+    "crates/jcode-base/src/auth/mod.rs": 1668,
+    "crates/jcode-base/src/auth/oauth.rs": 1524,
+    "crates/jcode-base/src/background.rs": 1667,
     "crates/jcode-base/src/compaction.rs": 1790,
-    "crates/jcode-base/src/gmail.rs": 1213,
+    "crates/jcode-base/src/gmail.rs": 1331,
     "crates/jcode-base/src/import.rs": 1495,
     "crates/jcode-base/src/memory.rs": 2065,
-    "crates/jcode-base/src/memory_agent.rs": 1901,
-    "crates/jcode-base/src/provider/catalog_routes.rs": 1653,
-    "crates/jcode-base/src/provider/mod.rs": 2886,
-    "crates/jcode-base/src/session.rs": 1634,
-    "crates/jcode-base/src/sidecar.rs": 1438,
-    "crates/jcode-base/src/skill.rs": 1426,
-    "crates/jcode-base/src/todo.rs": 2007,
-    "crates/jcode-config-types/src/lib.rs": 1549,
-    "crates/jcode-harness-api-server/src/translate.rs": 1851,
+    "crates/jcode-base/src/memory_agent.rs": 1949,
+    "crates/jcode-base/src/provider/catalog_routes.rs": 1714,
+    "crates/jcode-base/src/provider/mod.rs": 3014,
+    "crates/jcode-base/src/provider_catalog.rs": 1277,
+    "crates/jcode-base/src/session.rs": 1661,
+    "crates/jcode-base/src/sidecar.rs": 1497,
+    "crates/jcode-base/src/skill.rs": 1534,
+    "crates/jcode-base/src/todo.rs": 2188,
+    "crates/jcode-config-types/src/lib.rs": 1597,
+    "crates/jcode-harness-api-server/src/translate.rs": 2694,
     "crates/jcode-import-core/src/lib.rs": 1645,
     "crates/jcode-plan/src/lib.rs": 1201,
-    "crates/jcode-protocol/src/wire.rs": 1460,
-    "crates/jcode-provider-anthropic-runtime/src/lib.rs": 2499,
-    "crates/jcode-provider-bedrock/src/lib.rs": 1979,
-    "crates/jcode-provider-core/src/lib.rs": 1642,
-    "crates/jcode-provider-doctor/src/lifecycle_driver.rs": 1974,
-    "crates/jcode-provider-doctor/src/live_provider_probes.rs": 2031,
-    "crates/jcode-provider-doctor/src/provider_e2e.rs": 2713,
-    "crates/jcode-provider-openai-runtime/src/lib.rs": 1384,
-    "crates/jcode-provider-openai-runtime/src/openai_provider_impl.rs": 1229,
-    "crates/jcode-provider-openai-runtime/src/openai_stream_runtime.rs": 1654,
-    "crates/jcode-provider-openrouter-runtime/src/lib.rs": 2707,
+    "crates/jcode-protocol/src/wire.rs": 1508,
+    "crates/jcode-provider-anthropic-runtime/src/lib.rs": 2662,
+    "crates/jcode-provider-bedrock/src/lib.rs": 1981,
+    "crates/jcode-provider-core/src/lib.rs": 1742,
+    "crates/jcode-provider-doctor/src/lifecycle_driver.rs": 1980,
+    "crates/jcode-provider-doctor/src/live_provider_probes.rs": 2027,
+    "crates/jcode-provider-doctor/src/provider_e2e.rs": 2727,
+    "crates/jcode-provider-metadata/src/catalog.rs": 1312,
+    "crates/jcode-provider-openai-runtime/src/lib.rs": 1447,
+    "crates/jcode-provider-openai-runtime/src/openai_provider_impl.rs": 1263,
+    "crates/jcode-provider-openai-runtime/src/openai_stream_runtime.rs": 1741,
+    "crates/jcode-provider-openrouter-runtime/src/lib.rs": 2830,
     "crates/jcode-render-core/src/math.rs": 1234,
-    "crates/jcode-sdk/src/client.rs": 1379,
-    "crates/jcode-setup-hints/src/lib.rs": 2635,
-    "crates/jcode-telemetry-core/src/lib.rs": 2386,
+    "crates/jcode-sdk/src/client.rs": 1592,
+    "crates/jcode-setup-hints/src/lib.rs": 2631,
+    "crates/jcode-telemetry-core/src/lib.rs": 2594,
     "crates/jcode-terminal-launch/src/lib.rs": 1692,
+    "crates/jcode-tui-core/src/keybind.rs": 1207,
     "crates/jcode-tui-markdown/src/markdown_latex_image.rs": 1294,
-    "crates/jcode-tui-mermaid/src/lib.rs": 1497,
-    "crates/jcode-tui-mermaid/src/mermaid_cache_render.rs": 1475,
-    "crates/jcode-tui-mermaid/src/mermaid_viewport.rs": 1953,
+    "crates/jcode-tui-mermaid/src/lib.rs": 1606,
+    "crates/jcode-tui-mermaid/src/mermaid_cache_render.rs": 1477,
+    "crates/jcode-tui-mermaid/src/mermaid_viewport.rs": 1971,
     "crates/jcode-tui-render/src/swarm_gallery.rs": 3099,
-    "crates/jcode-tui/src/tui/app.rs": 2542,
-    "crates/jcode-tui/src/tui/app/auth.rs": 3433,
-    "crates/jcode-tui/src/tui/app/auth_account_commands.rs": 1202,
-    "crates/jcode-tui/src/tui/app/auth_account_picker.rs": 1220,
-    "crates/jcode-tui/src/tui/app/commands.rs": 3545,
+    "crates/jcode-tui/src/tui/app.rs": 2563,
+    "crates/jcode-tui/src/tui/app/auth.rs": 3540,
+    "crates/jcode-tui/src/tui/app/auth_account_commands.rs": 1208,
+    "crates/jcode-tui/src/tui/app/auth_account_picker.rs": 1275,
+    "crates/jcode-tui/src/tui/app/commands.rs": 3676,
     "crates/jcode-tui/src/tui/app/debug_bench.rs": 1284,
-    "crates/jcode-tui/src/tui/app/helpers.rs": 1502,
-    "crates/jcode-tui/src/tui/app/inline_interactive.rs": 4337,
-    "crates/jcode-tui/src/tui/app/input.rs": 4026,
+    "crates/jcode-tui/src/tui/app/helpers.rs": 1435,
+    "crates/jcode-tui/src/tui/app/inline_interactive.rs": 4753,
+    "crates/jcode-tui/src/tui/app/input.rs": 4204,
     "crates/jcode-tui/src/tui/app/model_context.rs": 1945,
-    "crates/jcode-tui/src/tui/app/navigation.rs": 1921,
-    "crates/jcode-tui/src/tui/app/onboarding_flow_control.rs": 1754,
-    "crates/jcode-tui/src/tui/app/remote.rs": 2100,
-    "crates/jcode-tui/src/tui/app/remote/key_handling.rs": 2639,
-    "crates/jcode-tui/src/tui/app/remote/server_events.rs": 2832,
-    "crates/jcode-tui/src/tui/app/run_shell.rs": 1357,
-    "crates/jcode-tui/src/tui/app/state_ui.rs": 2213,
-    "crates/jcode-tui/src/tui/app/state_ui_input_helpers.rs": 2088,
-    "crates/jcode-tui/src/tui/app/tui_lifecycle.rs": 1363,
-    "crates/jcode-tui/src/tui/app/tui_state.rs": 2417,
+    "crates/jcode-tui/src/tui/app/navigation.rs": 2002,
+    "crates/jcode-tui/src/tui/app/onboarding_flow_control.rs": 1766,
+    "crates/jcode-tui/src/tui/app/remote.rs": 2181,
+    "crates/jcode-tui/src/tui/app/remote/key_handling.rs": 2706,
+    "crates/jcode-tui/src/tui/app/remote/server_events.rs": 2917,
+    "crates/jcode-tui/src/tui/app/run_shell.rs": 1415,
+    "crates/jcode-tui/src/tui/app/state_ui.rs": 2237,
+    "crates/jcode-tui/src/tui/app/state_ui_input_helpers.rs": 2100,
+    "crates/jcode-tui/src/tui/app/tui_lifecycle.rs": 1394,
+    "crates/jcode-tui/src/tui/app/tui_state.rs": 2462,
     "crates/jcode-tui/src/tui/app/turn.rs": 1485,
-    "crates/jcode-tui/src/tui/backend.rs": 1863,
-    "crates/jcode-tui/src/tui/info_widget.rs": 2233,
-    "crates/jcode-tui/src/tui/mod.rs": 1881,
-    "crates/jcode-tui/src/tui/session_picker.rs": 2437,
-    "crates/jcode-tui/src/tui/session_picker/loading.rs": 2983,
-    "crates/jcode-tui/src/tui/ui.rs": 3683,
-    "crates/jcode-tui/src/tui/ui_frame_metrics.rs": 1437,
-    "crates/jcode-tui/src/tui/ui_header.rs": 1758,
-    "crates/jcode-tui/src/tui/ui_inline_image.rs": 1726,
-    "crates/jcode-tui/src/tui/ui_inline_interactive.rs": 1268,
-    "crates/jcode-tui/src/tui/ui_input.rs": 3188,
-    "crates/jcode-tui/src/tui/ui_messages.rs": 4417,
-    "crates/jcode-tui/src/tui/ui_pinned.rs": 2046,
+    "crates/jcode-tui/src/tui/backend.rs": 1961,
+    "crates/jcode-tui/src/tui/info_widget.rs": 2239,
+    "crates/jcode-tui/src/tui/mod.rs": 2022,
+    "crates/jcode-tui/src/tui/session_picker.rs": 2451,
+    "crates/jcode-tui/src/tui/session_picker/loading.rs": 3038,
+    "crates/jcode-tui/src/tui/ui.rs": 3761,
+    "crates/jcode-tui/src/tui/ui_frame_metrics.rs": 1438,
+    "crates/jcode-tui/src/tui/ui_header.rs": 1767,
+    "crates/jcode-tui/src/tui/ui_inline_image.rs": 1797,
+    "crates/jcode-tui/src/tui/ui_inline_interactive.rs": 1377,
+    "crates/jcode-tui/src/tui/ui_input.rs": 3211,
+    "crates/jcode-tui/src/tui/ui_messages.rs": 4478,
+    "crates/jcode-tui/src/tui/ui_pinned.rs": 2060,
     "crates/jcode-tui/src/tui/ui_prepare.rs": 2675,
-    "crates/jcode-tui/src/tui/ui_tools.rs": 1656,
-    "crates/jcode-tui/src/tui/ui_viewport.rs": 1514,
+    "crates/jcode-tui/src/tui/ui_tools.rs": 1683,
+    "crates/jcode-tui/src/tui/ui_viewport.rs": 1676,
     "src/bin/memory_recall_bench.rs": 2667,
     "src/bin/tui_bench.rs": 1763,
-    "src/cli/acp.rs": 1641,
-    "src/cli/commands.rs": 3375,
-    "src/cli/dispatch.rs": 1435,
-    "src/cli/login.rs": 1389,
-    "src/cli/provider_init.rs": 1859
+    "src/cli/acp.rs": 2195,
+    "src/cli/commands.rs": 3482,
+    "src/cli/dispatch.rs": 1513,
+    "src/cli/login.rs": 1454,
+    "src/cli/provider_init.rs": 1908
   },
   "version": 1
 }
diff --git a/scripts/panic_budget.json b/scripts/panic_budget.json
index 8d332775c2..7bae5e6147 100644
--- a/scripts/panic_budget.json
+++ b/scripts/panic_budget.json
@@ -1,26 +1,49 @@
 {
-  "total": 77,
+  "total": 139,
   "tracked_files": {
+    "crates/jcode-app-core/build.rs": 4,
+    "crates/jcode-app-core/src/agent/provider.rs": 1,
     "crates/jcode-app-core/src/session_launch.rs": 1,
+    "crates/jcode-app-core/src/tool/bash.rs": 2,
+    "crates/jcode-app-core/src/tool/browser_fast.rs": 4,
     "crates/jcode-app-core/src/tool/communicate.rs": 1,
     "crates/jcode-app-core/src/tool/computer/win.rs": 3,
+    "crates/jcode-app-core/src/tool/discover.rs": 1,
     "crates/jcode-base/src/auth/oauth.rs": 3,
     "crates/jcode-base/src/hooks.rs": 1,
+    "crates/jcode-base/src/provider_activity_oauth.rs": 3,
     "crates/jcode-harness-api-server/src/translate.rs": 2,
     "crates/jcode-harness-api/examples/harness_repl.rs": 15,
     "crates/jcode-plan/src/dag/ops.rs": 1,
     "crates/jcode-provider-anthropic/src/wedge_fixture_check.rs": 3,
     "crates/jcode-provider-doctor/src/lifecycle_driver.rs": 2,
+    "crates/jcode-provider-grok-build-runtime/src/bin/fake_acp.rs": 8,
+    "crates/jcode-provider-openai/src/stream.rs": 2,
     "crates/jcode-render-core/src/math.rs": 4,
     "crates/jcode-render-core/src/preprocess.rs": 2,
+    "crates/jcode-render-core/src/reasoning.rs": 1,
+    "crates/jcode-sdk/src/auth.rs": 16,
+    "crates/jcode-sdk/src/ssh.rs": 3,
     "crates/jcode-sdk/src/structured.rs": 1,
-    "crates/jcode-telemetry-core/src/lib.rs": 2,
+    "crates/jcode-sdk/src/worktrees.rs": 1,
+    "crates/jcode-telemetry-core/src/concurrency.rs": 2,
+    "crates/jcode-telemetry-core/src/lib.rs": 5,
     "crates/jcode-terminal-launch/src/lib.rs": 1,
     "crates/jcode-tui-core/src/stream_buffer.rs": 3,
     "crates/jcode-tui-style/examples/light_bench.rs": 1,
+    "crates/jcode-tui-style/src/theme_mode.rs": 1,
+    "crates/jcode-tui/src/tui/app/auth.rs": 3,
+    "crates/jcode-tui/src/tui/app/auth_account_picker.rs": 2,
+    "crates/jcode-tui/src/tui/app/auth_remote.rs": 12,
+    "crates/jcode-tui/src/tui/app/auth_remote/onboarding.rs": 1,
+    "crates/jcode-tui/src/tui/app/auth_remote/picker.rs": 1,
     "crates/jcode-tui/src/tui/session_picker.rs": 2,
+    "crates/jcode-tui/src/tui/ui_inline_interactive.rs": 1,
     "src/bin/memory_recall_bench.rs": 14,
-    "src/cli/commands/menubar.rs": 1
+    "src/cli/acp.rs": 2,
+    "src/cli/commands/menubar.rs": 1,
+    "src/cli/ssh.rs": 1,
+    "src/cli/tui_launch.rs": 1
   },
   "version": 1
 }
diff --git a/scripts/swallowed_error_budget.json b/scripts/swallowed_error_budget.json
index cc79cb00ce..de5d6f5dc6 100644
--- a/scripts/swallowed_error_budget.json
+++ b/scripts/swallowed_error_budget.json
@@ -1,9 +1,9 @@
 {
-  "total": 3248,
+  "total": 3365,
   "totals_by_pattern": {
-    "dot_ok": 1218,
-    "let_underscore": 1202,
-    "unwrap_or_default": 828
+    "dot_ok": 1269,
+    "let_underscore": 1257,
+    "unwrap_or_default": 839
   },
   "tracked_files": {
     "crates/jcode-app-core/src/agent.rs": {
@@ -131,9 +131,14 @@
       "let_underscore": 1,
       "unwrap_or_default": 1
     },
+    "crates/jcode-app-core/src/server/background_tasks.rs": {
+      "dot_ok": 0,
+      "let_underscore": 1,
+      "unwrap_or_default": 0
+    },
     "crates/jcode-app-core/src/server/client_actions.rs": {
-      "dot_ok": 1,
-      "let_underscore": 41,
+      "dot_ok": 2,
+      "let_underscore": 42,
       "unwrap_or_default": 1
     },
     "crates/jcode-app-core/src/server/client_comm_channels.rs": {
@@ -148,13 +153,13 @@
     },
     "crates/jcode-app-core/src/server/client_comm_message.rs": {
       "dot_ok": 0,
-      "let_underscore": 7,
+      "let_underscore": 8,
       "unwrap_or_default": 2
     },
     "crates/jcode-app-core/src/server/client_lifecycle.rs": {
-      "dot_ok": 0,
-      "let_underscore": 33,
-      "unwrap_or_default": 0
+      "dot_ok": 2,
+      "let_underscore": 38,
+      "unwrap_or_default": 1
     },
     "crates/jcode-app-core/src/server/client_lifecycle_logging.rs": {
       "dot_ok": 1,
@@ -267,7 +272,7 @@
       "unwrap_or_default": 0
     },
     "crates/jcode-app-core/src/server/live_turn.rs": {
-      "dot_ok": 0,
+      "dot_ok": 1,
       "let_underscore": 2,
       "unwrap_or_default": 0
     },
@@ -382,13 +387,13 @@
       "unwrap_or_default": 1
     },
     "crates/jcode-app-core/src/tool/apply_patch.rs": {
-      "dot_ok": 0,
-      "let_underscore": 2,
-      "unwrap_or_default": 1
+      "dot_ok": 3,
+      "let_underscore": 1,
+      "unwrap_or_default": 0
     },
     "crates/jcode-app-core/src/tool/bash.rs": {
       "dot_ok": 16,
-      "let_underscore": 12,
+      "let_underscore": 9,
       "unwrap_or_default": 4
     },
     "crates/jcode-app-core/src/tool/bg.rs": {
@@ -401,6 +406,11 @@
       "let_underscore": 1,
       "unwrap_or_default": 3
     },
+    "crates/jcode-app-core/src/tool/browser_fast.rs": {
+      "dot_ok": 0,
+      "let_underscore": 0,
+      "unwrap_or_default": 1
+    },
     "crates/jcode-app-core/src/tool/communicate.rs": {
       "dot_ok": 0,
       "let_underscore": 4,
@@ -449,7 +459,7 @@
     "crates/jcode-app-core/src/tool/discover.rs": {
       "dot_ok": 3,
       "let_underscore": 0,
-      "unwrap_or_default": 4
+      "unwrap_or_default": 6
     },
     "crates/jcode-app-core/src/tool/discover_secrets.rs": {
       "dot_ok": 0,
@@ -479,7 +489,7 @@
     "crates/jcode-app-core/src/tool/mcp.rs": {
       "dot_ok": 0,
       "let_underscore": 0,
-      "unwrap_or_default": 2
+      "unwrap_or_default": 3
     },
     "crates/jcode-app-core/src/tool/mod.rs": {
       "dot_ok": 0,
@@ -492,9 +502,9 @@
       "unwrap_or_default": 0
     },
     "crates/jcode-app-core/src/tool/patch.rs": {
-      "dot_ok": 1,
+      "dot_ok": 2,
       "let_underscore": 0,
-      "unwrap_or_default": 1
+      "unwrap_or_default": 0
     },
     "crates/jcode-app-core/src/tool/read.rs": {
       "dot_ok": 1,
@@ -502,9 +512,9 @@
       "unwrap_or_default": 1
     },
     "crates/jcode-app-core/src/tool/selfdev/build_queue.rs": {
-      "dot_ok": 2,
-      "let_underscore": 4,
-      "unwrap_or_default": 2
+      "dot_ok": 1,
+      "let_underscore": 3,
+      "unwrap_or_default": 0
     },
     "crates/jcode-app-core/src/tool/selfdev/mod.rs": {
       "dot_ok": 8,
@@ -566,6 +576,11 @@
       "let_underscore": 6,
       "unwrap_or_default": 9
     },
+    "crates/jcode-app-core/src/update_dev_guard.rs": {
+      "dot_ok": 4,
+      "let_underscore": 0,
+      "unwrap_or_default": 0
+    },
     "crates/jcode-app-core/src/update_metadata.rs": {
       "dot_ok": 1,
       "let_underscore": 2,
@@ -608,7 +623,7 @@
     },
     "crates/jcode-base/src/auth/cursor.rs": {
       "dot_ok": 10,
-      "let_underscore": 3,
+      "let_underscore": 1,
       "unwrap_or_default": 0
     },
     "crates/jcode-base/src/auth/env_facts.rs": {
@@ -631,6 +646,11 @@
       "let_underscore": 0,
       "unwrap_or_default": 0
     },
+    "crates/jcode-base/src/auth/grok_build.rs": {
+      "dot_ok": 5,
+      "let_underscore": 0,
+      "unwrap_or_default": 4
+    },
     "crates/jcode-base/src/auth/lifecycle.rs": {
       "dot_ok": 4,
       "let_underscore": 0,
@@ -661,19 +681,24 @@
       "let_underscore": 0,
       "unwrap_or_default": 0
     },
+    "crates/jcode-base/src/auth/transfer.rs": {
+      "dot_ok": 0,
+      "let_underscore": 1,
+      "unwrap_or_default": 0
+    },
     "crates/jcode-base/src/auth/validation.rs": {
       "dot_ok": 0,
       "let_underscore": 0,
       "unwrap_or_default": 1
     },
     "crates/jcode-base/src/background.rs": {
-      "dot_ok": 14,
+      "dot_ok": 16,
       "let_underscore": 17,
-      "unwrap_or_default": 9
+      "unwrap_or_default": 11
     },
     "crates/jcode-base/src/browser.rs": {
       "dot_ok": 5,
-      "let_underscore": 6,
+      "let_underscore": 7,
       "unwrap_or_default": 2
     },
     "crates/jcode-base/src/bus.rs": {
@@ -704,7 +729,7 @@
     "crates/jcode-base/src/config/config_file.rs": {
       "dot_ok": 1,
       "let_underscore": 4,
-      "unwrap_or_default": 2
+      "unwrap_or_default": 3
     },
     "crates/jcode-base/src/config/env_overrides.rs": {
       "dot_ok": 1,
@@ -851,9 +876,14 @@
       "let_underscore": 1,
       "unwrap_or_default": 0
     },
+    "crates/jcode-base/src/model_usage.rs": {
+      "dot_ok": 1,
+      "let_underscore": 0,
+      "unwrap_or_default": 2
+    },
     "crates/jcode-base/src/platform.rs": {
       "dot_ok": 1,
-      "let_underscore": 7,
+      "let_underscore": 9,
       "unwrap_or_default": 0
     },
     "crates/jcode-base/src/process_memory.rs": {
@@ -867,8 +897,8 @@
       "unwrap_or_default": 0
     },
     "crates/jcode-base/src/prompt.rs": {
-      "dot_ok": 11,
-      "let_underscore": 0,
+      "dot_ok": 12,
+      "let_underscore": 1,
       "unwrap_or_default": 0
     },
     "crates/jcode-base/src/provider/account_failover.rs": {
@@ -876,6 +906,11 @@
       "let_underscore": 0,
       "unwrap_or_default": 2
     },
+    "crates/jcode-base/src/provider/anthropic.rs": {
+      "dot_ok": 1,
+      "let_underscore": 0,
+      "unwrap_or_default": 0
+    },
     "crates/jcode-base/src/provider/antigravity.rs": {
       "dot_ok": 2,
       "let_underscore": 1,
@@ -897,7 +932,7 @@
       "unwrap_or_default": 0
     },
     "crates/jcode-base/src/provider/mod.rs": {
-      "dot_ok": 3,
+      "dot_ok": 4,
       "let_underscore": 1,
       "unwrap_or_default": 15
     },
@@ -932,7 +967,7 @@
       "unwrap_or_default": 0
     },
     "crates/jcode-base/src/provider/startup.rs": {
-      "dot_ok": 2,
+      "dot_ok": 4,
       "let_underscore": 0,
       "unwrap_or_default": 0
     },
@@ -941,11 +976,21 @@
       "let_underscore": 1,
       "unwrap_or_default": 1
     },
+    "crates/jcode-base/src/provider_activity_oauth.rs": {
+      "dot_ok": 0,
+      "let_underscore": 0,
+      "unwrap_or_default": 1
+    },
     "crates/jcode-base/src/provider_catalog.rs": {
       "dot_ok": 7,
       "let_underscore": 0,
       "unwrap_or_default": 0
     },
+    "crates/jcode-base/src/recent_session_index.rs": {
+      "dot_ok": 0,
+      "let_underscore": 1,
+      "unwrap_or_default": 0
+    },
     "crates/jcode-base/src/registry.rs": {
       "dot_ok": 3,
       "let_underscore": 0,
@@ -1158,24 +1203,34 @@
     },
     "crates/jcode-harness-api-server/src/lib.rs": {
       "dot_ok": 2,
-      "let_underscore": 2,
-      "unwrap_or_default": 0
+      "let_underscore": 4,
+      "unwrap_or_default": 1
     },
     "crates/jcode-harness-api-server/src/translate.rs": {
-      "dot_ok": 12,
-      "let_underscore": 2,
-      "unwrap_or_default": 23
+      "dot_ok": 18,
+      "let_underscore": 5,
+      "unwrap_or_default": 32
     },
     "crates/jcode-harness-api/examples/harness_repl.rs": {
       "dot_ok": 0,
       "let_underscore": 1,
       "unwrap_or_default": 0
     },
+    "crates/jcode-harness-api/src/edit_stats.rs": {
+      "dot_ok": 8,
+      "let_underscore": 0,
+      "unwrap_or_default": 0
+    },
     "crates/jcode-harness-api/src/sockets.rs": {
       "dot_ok": 2,
       "let_underscore": 0,
       "unwrap_or_default": 0
     },
+    "crates/jcode-harness-api/src/swarm_metadata.rs": {
+      "dot_ok": 2,
+      "let_underscore": 0,
+      "unwrap_or_default": 0
+    },
     "crates/jcode-import-core/src/lib.rs": {
       "dot_ok": 10,
       "let_underscore": 0,
@@ -1244,7 +1299,7 @@
     "crates/jcode-protocol/src/comm_format.rs": {
       "dot_ok": 0,
       "let_underscore": 0,
-      "unwrap_or_default": 1
+      "unwrap_or_default": 2
     },
     "crates/jcode-protocol/src/lib.rs": {
       "dot_ok": 1,
@@ -1252,13 +1307,13 @@
       "unwrap_or_default": 0
     },
     "crates/jcode-provider-anthropic-runtime/src/lib.rs": {
-      "dot_ok": 4,
+      "dot_ok": 9,
       "let_underscore": 15,
       "unwrap_or_default": 1
     },
     "crates/jcode-provider-antigravity-runtime/src/lib.rs": {
       "dot_ok": 2,
-      "let_underscore": 19,
+      "let_underscore": 21,
       "unwrap_or_default": 3
     },
     "crates/jcode-provider-antigravity/src/lib.rs": {
@@ -1366,6 +1421,11 @@
       "let_underscore": 0,
       "unwrap_or_default": 1
     },
+    "crates/jcode-provider-grok-build-runtime/src/lib.rs": {
+      "dot_ok": 0,
+      "let_underscore": 6,
+      "unwrap_or_default": 0
+    },
     "crates/jcode-provider-metadata/src/lib.rs": {
       "dot_ok": 1,
       "let_underscore": 0,
@@ -1393,9 +1453,19 @@
     },
     "crates/jcode-provider-openai-runtime/src/openai_stream_runtime.rs": {
       "dot_ok": 0,
-      "let_underscore": 5,
+      "let_underscore": 7,
       "unwrap_or_default": 1
     },
+    "crates/jcode-provider-openai-runtime/src/openai_usage_recording.rs": {
+      "dot_ok": 1,
+      "let_underscore": 0,
+      "unwrap_or_default": 0
+    },
+    "crates/jcode-provider-openai-runtime/src/openai_websocket_prewarm.rs": {
+      "dot_ok": 1,
+      "let_underscore": 1,
+      "unwrap_or_default": 0
+    },
     "crates/jcode-provider-openai/src/request.rs": {
       "dot_ok": 0,
       "let_underscore": 0,
@@ -1461,21 +1531,41 @@
       "let_underscore": 2,
       "unwrap_or_default": 2
     },
+    "crates/jcode-sdk/src/auth.rs": {
+      "dot_ok": 0,
+      "let_underscore": 10,
+      "unwrap_or_default": 0
+    },
+    "crates/jcode-sdk/src/auth/callback.rs": {
+      "dot_ok": 10,
+      "let_underscore": 1,
+      "unwrap_or_default": 0
+    },
     "crates/jcode-sdk/src/client.rs": {
       "dot_ok": 6,
-      "let_underscore": 4,
+      "let_underscore": 6,
       "unwrap_or_default": 0
     },
     "crates/jcode-sdk/src/launch.rs": {
       "dot_ok": 5,
-      "let_underscore": 7,
+      "let_underscore": 9,
       "unwrap_or_default": 3
     },
+    "crates/jcode-sdk/src/ssh.rs": {
+      "dot_ok": 1,
+      "let_underscore": 4,
+      "unwrap_or_default": 2
+    },
     "crates/jcode-sdk/src/structured.rs": {
       "dot_ok": 0,
       "let_underscore": 0,
       "unwrap_or_default": 2
     },
+    "crates/jcode-selfdev-types/src/desktop.rs": {
+      "dot_ok": 3,
+      "let_underscore": 0,
+      "unwrap_or_default": 0
+    },
     "crates/jcode-session-types/src/lib.rs": {
       "dot_ok": 0,
       "let_underscore": 0,
@@ -1511,6 +1601,11 @@
       "let_underscore": 21,
       "unwrap_or_default": 14
     },
+    "crates/jcode-setup-hints/src/linux_niri.rs": {
+      "dot_ok": 0,
+      "let_underscore": 0,
+      "unwrap_or_default": 1
+    },
     "crates/jcode-setup-hints/src/macos_launcher.rs": {
       "dot_ok": 1,
       "let_underscore": 3,
@@ -1524,7 +1619,7 @@
     "crates/jcode-setup-hints/src/windows_setup.rs": {
       "dot_ok": 2,
       "let_underscore": 11,
-      "unwrap_or_default": 4
+      "unwrap_or_default": 2
     },
     "crates/jcode-storage/src/active_pids.rs": {
       "dot_ok": 15,
@@ -1541,9 +1636,14 @@
       "let_underscore": 0,
       "unwrap_or_default": 1
     },
+    "crates/jcode-telemetry-core/src/concurrency.rs": {
+      "dot_ok": 4,
+      "let_underscore": 5,
+      "unwrap_or_default": 1
+    },
     "crates/jcode-telemetry-core/src/lib.rs": {
       "dot_ok": 8,
-      "let_underscore": 10,
+      "let_underscore": 12,
       "unwrap_or_default": 3
     },
     "crates/jcode-telemetry-core/src/lifecycle.rs": {
@@ -1553,7 +1653,7 @@
     },
     "crates/jcode-telemetry-core/src/state_support.rs": {
       "dot_ok": 22,
-      "let_underscore": 8,
+      "let_underscore": 5,
       "unwrap_or_default": 0
     },
     "crates/jcode-terminal-image/src/display.rs": {
@@ -1627,7 +1727,7 @@
       "unwrap_or_default": 0
     },
     "crates/jcode-tui-mermaid/src/lib.rs": {
-      "dot_ok": 2,
+      "dot_ok": 5,
       "let_underscore": 4,
       "unwrap_or_default": 3
     },
@@ -1657,9 +1757,9 @@
       "unwrap_or_default": 0
     },
     "crates/jcode-tui-mermaid/src/mermaid_runtime.rs": {
-      "dot_ok": 21,
+      "dot_ok": 24,
       "let_underscore": 2,
-      "unwrap_or_default": 3
+      "unwrap_or_default": 5
     },
     "crates/jcode-tui-mermaid/src/mermaid_svg.rs": {
       "dot_ok": 19,
@@ -1718,12 +1818,12 @@
     },
     "crates/jcode-tui/src/tui/app/auth.rs": {
       "dot_ok": 7,
-      "let_underscore": 3,
+      "let_underscore": 4,
       "unwrap_or_default": 13
     },
     "crates/jcode-tui/src/tui/app/auth_account_commands.rs": {
       "dot_ok": 0,
-      "let_underscore": 3,
+      "let_underscore": 2,
       "unwrap_or_default": 3
     },
     "crates/jcode-tui/src/tui/app/auth_account_picker.rs": {
@@ -1736,6 +1836,11 @@
       "let_underscore": 0,
       "unwrap_or_default": 4
     },
+    "crates/jcode-tui/src/tui/app/auth_remote/command.rs": {
+      "dot_ok": 4,
+      "let_underscore": 6,
+      "unwrap_or_default": 2
+    },
     "crates/jcode-tui/src/tui/app/catchup.rs": {
       "dot_ok": 0,
       "let_underscore": 1,
@@ -1743,9 +1848,14 @@
     },
     "crates/jcode-tui/src/tui/app/commands.rs": {
       "dot_ok": 4,
-      "let_underscore": 9,
+      "let_underscore": 14,
       "unwrap_or_default": 20
     },
+    "crates/jcode-tui/src/tui/app/commands_dispatch.rs": {
+      "dot_ok": 0,
+      "let_underscore": 0,
+      "unwrap_or_default": 1
+    },
     "crates/jcode-tui/src/tui/app/commands_improve.rs": {
       "dot_ok": 0,
       "let_underscore": 2,
@@ -1769,7 +1879,7 @@
     "crates/jcode-tui/src/tui/app/copy_selection.rs": {
       "dot_ok": 0,
       "let_underscore": 0,
-      "unwrap_or_default": 2
+      "unwrap_or_default": 3
     },
     "crates/jcode-tui/src/tui/app/debug.rs": {
       "dot_ok": 0,
@@ -1807,7 +1917,7 @@
       "unwrap_or_default": 0
     },
     "crates/jcode-tui/src/tui/app/helpers.rs": {
-      "dot_ok": 13,
+      "dot_ok": 11,
       "let_underscore": 2,
       "unwrap_or_default": 4
     },
@@ -1823,7 +1933,7 @@
     },
     "crates/jcode-tui/src/tui/app/inline_interactive.rs": {
       "dot_ok": 6,
-      "let_underscore": 11,
+      "let_underscore": 12,
       "unwrap_or_default": 4
     },
     "crates/jcode-tui/src/tui/app/inline_interactive/helpers.rs": {
@@ -1837,13 +1947,13 @@
       "unwrap_or_default": 1
     },
     "crates/jcode-tui/src/tui/app/input.rs": {
-      "dot_ok": 9,
-      "let_underscore": 3,
+      "dot_ok": 10,
+      "let_underscore": 4,
       "unwrap_or_default": 4
     },
     "crates/jcode-tui/src/tui/app/local.rs": {
       "dot_ok": 0,
-      "let_underscore": 5,
+      "let_underscore": 6,
       "unwrap_or_default": 0
     },
     "crates/jcode-tui/src/tui/app/model_context.rs": {
@@ -1888,7 +1998,7 @@
     },
     "crates/jcode-tui/src/tui/app/remote/key_handling.rs": {
       "dot_ok": 0,
-      "let_underscore": 19,
+      "let_underscore": 17,
       "unwrap_or_default": 10
     },
     "crates/jcode-tui/src/tui/app/remote/reconnect.rs": {
@@ -1974,7 +2084,7 @@
     "crates/jcode-tui/src/tui/app/todos_view.rs": {
       "dot_ok": 0,
       "let_underscore": 0,
-      "unwrap_or_default": 5
+      "unwrap_or_default": 4
     },
     "crates/jcode-tui/src/tui/app/tui_lifecycle.rs": {
       "dot_ok": 9,
@@ -1983,7 +2093,7 @@
     },
     "crates/jcode-tui/src/tui/app/tui_lifecycle_runtime.rs": {
       "dot_ok": 5,
-      "let_underscore": 6,
+      "let_underscore": 7,
       "unwrap_or_default": 4
     },
     "crates/jcode-tui/src/tui/app/tui_state.rs": {
@@ -2037,7 +2147,7 @@
       "unwrap_or_default": 0
     },
     "crates/jcode-tui/src/tui/mod.rs": {
-      "dot_ok": 1,
+      "dot_ok": 2,
       "let_underscore": 1,
       "unwrap_or_default": 1
     },
@@ -2097,7 +2207,7 @@
       "unwrap_or_default": 3
     },
     "crates/jcode-tui/src/tui/ui/url.rs": {
-      "dot_ok": 1,
+      "dot_ok": 2,
       "let_underscore": 0,
       "unwrap_or_default": 0
     },
@@ -2127,14 +2237,14 @@
       "unwrap_or_default": 3
     },
     "crates/jcode-tui/src/tui/ui_inline_image.rs": {
-      "dot_ok": 5,
+      "dot_ok": 6,
       "let_underscore": 0,
       "unwrap_or_default": 1
     },
     "crates/jcode-tui/src/tui/ui_inline_interactive.rs": {
       "dot_ok": 0,
       "let_underscore": 0,
-      "unwrap_or_default": 1
+      "unwrap_or_default": 2
     },
     "crates/jcode-tui/src/tui/ui_input.rs": {
       "dot_ok": 3,
@@ -2182,9 +2292,9 @@
       "unwrap_or_default": 0
     },
     "crates/jcode-tui/src/tui/ui_viewport.rs": {
-      "dot_ok": 2,
+      "dot_ok": 3,
       "let_underscore": 0,
-      "unwrap_or_default": 0
+      "unwrap_or_default": 1
     },
     "crates/jcode-tui/src/tui/workspace_client.rs": {
       "dot_ok": 0,
@@ -2219,10 +2329,10 @@
     "src/cli/acp.rs": {
       "dot_ok": 1,
       "let_underscore": 5,
-      "unwrap_or_default": 3
+      "unwrap_or_default": 4
     },
     "src/cli/commands.rs": {
-      "dot_ok": 11,
+      "dot_ok": 12,
       "let_underscore": 4,
       "unwrap_or_default": 9
     },
@@ -2281,6 +2391,16 @@
       "let_underscore": 1,
       "unwrap_or_default": 0
     },
+    "src/cli/ssh.rs": {
+      "dot_ok": 1,
+      "let_underscore": 1,
+      "unwrap_or_default": 0
+    },
+    "src/cli/ssh_transport.rs": {
+      "dot_ok": 0,
+      "let_underscore": 10,
+      "unwrap_or_default": 3
+    },
     "src/cli/startup.rs": {
       "dot_ok": 3,
       "let_underscore": 0,
@@ -2293,8 +2413,8 @@
     },
     "src/cli/tui_launch.rs": {
       "dot_ok": 0,
-      "let_underscore": 4,
-      "unwrap_or_default": 0
+      "let_underscore": 5,
+      "unwrap_or_default": 1
     },
     "src/main.rs": {
       "dot_ok": 2,
diff --git a/scripts/test_size_budget.json b/scripts/test_size_budget.json
index 1ada7f8ca0..bda6bdcae2 100644
--- a/scripts/test_size_budget.json
+++ b/scripts/test_size_budget.json
@@ -1,45 +1,53 @@
 {
   "threshold_loc": 1200,
   "tracked_files": {
-    "crates/jcode-app-core/src/agent_tests.rs": 1760,
-    "crates/jcode-app-core/src/server/client_lifecycle_tests.rs": 1410,
+    "crates/jcode-app-core/src/agent_tests.rs": 2237,
+    "crates/jcode-app-core/src/server/client_lifecycle_tests.rs": 1466,
     "crates/jcode-app-core/src/server/comm_control_tests/dag_e2e.rs": 1332,
-    "crates/jcode-app-core/src/server/provider_control_tests.rs": 1393,
+    "crates/jcode-app-core/src/server/comm_session_tests.rs": 1207,
+    "crates/jcode-app-core/src/server/provider_control_tests.rs": 1397,
     "crates/jcode-app-core/src/server/swarm_persistence_tests.rs": 1232,
-    "crates/jcode-app-core/src/tool/communicate_tests.rs": 1796,
-    "crates/jcode-app-core/src/tool/selfdev/tests.rs": 1440,
-    "crates/jcode-app-core/src/tool/tests.rs": 1586,
-    "crates/jcode-base/src/config_tests.rs": 1335,
+    "crates/jcode-app-core/src/tool/bash_tests.rs": 1216,
+    "crates/jcode-app-core/src/tool/communicate_tests.rs": 1875,
+    "crates/jcode-app-core/src/tool/selfdev/tests.rs": 1443,
+    "crates/jcode-app-core/src/tool/tests.rs": 1780,
+    "crates/jcode-base/src/config_tests.rs": 1465,
     "crates/jcode-base/src/live_tests.rs": 3087,
+    "crates/jcode-base/src/provider/tests.rs": 1207,
     "crates/jcode-base/src/provider/tests/model_resolution.rs": 2435,
-    "crates/jcode-base/src/session_tests/cases.rs": 2465,
-    "crates/jcode-harness-api-server/src/translate_tests.rs": 1390,
+    "crates/jcode-base/src/provider_catalog_tests.rs": 1347,
+    "crates/jcode-base/src/session_tests/cases.rs": 2664,
+    "crates/jcode-harness-api-server/src/translate_tests.rs": 2716,
     "crates/jcode-plan/src/dag/tests.rs": 1392,
-    "crates/jcode-provider-anthropic-runtime/src/anthropic_tests.rs": 2017,
-    "crates/jcode-provider-openrouter-runtime/src/openrouter_tests.rs": 3164,
-    "crates/jcode-tui/src/tui/app/tests.rs": 1776,
-    "crates/jcode-tui/src/tui/app/tests/commands_accounts_01/part_01.rs": 1673,
+    "crates/jcode-provider-anthropic-runtime/src/anthropic_tests.rs": 2105,
+    "crates/jcode-provider-openrouter-runtime/src/openrouter_tests.rs": 3706,
+    "crates/jcode-telemetry-core/src/tests.rs": 1442,
+    "crates/jcode-tui-markdown/src/markdown_tests/cases/rendering.rs": 1207,
+    "crates/jcode-tui/src/tui/app/remote_tests.rs": 1248,
+    "crates/jcode-tui/src/tui/app/tests.rs": 1808,
+    "crates/jcode-tui/src/tui/app/tests/commands_accounts_01/part_01.rs": 1677,
     "crates/jcode-tui/src/tui/app/tests/onboarding_eval.rs": 3303,
-    "crates/jcode-tui/src/tui/app/tests/onboarding_flow.rs": 1818,
-    "crates/jcode-tui/src/tui/app/tests/remote_events_reload_01/part_01.rs": 1930,
-    "crates/jcode-tui/src/tui/app/tests/remote_events_reload_04.rs": 2415,
-    "crates/jcode-tui/src/tui/app/tests/remote_startup_input_02/part_01.rs": 2023,
-    "crates/jcode-tui/src/tui/app/tests/remote_startup_input_03/part_01.rs": 1229,
-    "crates/jcode-tui/src/tui/app/tests/scroll_copy_02/part_01.rs": 1442,
-    "crates/jcode-tui/src/tui/app/tests/scroll_copy_02/part_02.rs": 1321,
+    "crates/jcode-tui/src/tui/app/tests/onboarding_flow.rs": 1821,
+    "crates/jcode-tui/src/tui/app/tests/remote_events_reload_01/part_01.rs": 2021,
+    "crates/jcode-tui/src/tui/app/tests/remote_events_reload_04.rs": 2493,
+    "crates/jcode-tui/src/tui/app/tests/remote_startup_input_02/part_01.rs": 2046,
+    "crates/jcode-tui/src/tui/app/tests/remote_startup_input_03/part_01.rs": 1308,
+    "crates/jcode-tui/src/tui/app/tests/scroll_copy_01/part_01.rs": 1257,
+    "crates/jcode-tui/src/tui/app/tests/scroll_copy_02/part_01.rs": 1483,
+    "crates/jcode-tui/src/tui/app/tests/scroll_copy_02/part_02.rs": 1368,
     "crates/jcode-tui/src/tui/app/tests/scroll_copy_03.rs": 1842,
-    "crates/jcode-tui/src/tui/app/tests/state_model_poke_01/part_01.rs": 1356,
-    "crates/jcode-tui/src/tui/app/tests/state_model_poke_02/part_01.rs": 1376,
-    "crates/jcode-tui/src/tui/app/tests/state_model_poke_03.rs": 2870,
-    "crates/jcode-tui/src/tui/app/tests/swarm_plan_graph_inline.rs": 1980,
+    "crates/jcode-tui/src/tui/app/tests/state_model_poke_01/part_01.rs": 1370,
+    "crates/jcode-tui/src/tui/app/tests/state_model_poke_02/part_01.rs": 1575,
+    "crates/jcode-tui/src/tui/app/tests/state_model_poke_03.rs": 3020,
+    "crates/jcode-tui/src/tui/app/tests/swarm_plan_graph_inline.rs": 1981,
     "crates/jcode-tui/src/tui/info_widget_tests.rs": 1815,
-    "crates/jcode-tui/src/tui/session_picker/loading_tests.rs": 1401,
-    "crates/jcode-tui/src/tui/session_picker_tests.rs": 2453,
-    "crates/jcode-tui/src/tui/ui_messages/tests.rs": 3151,
+    "crates/jcode-tui/src/tui/session_picker/loading_tests.rs": 1461,
+    "crates/jcode-tui/src/tui/session_picker_tests.rs": 2601,
+    "crates/jcode-tui/src/tui/ui_messages/tests.rs": 3344,
     "crates/jcode-tui/src/tui/ui_tests/prepare.rs": 1285,
-    "crates/jcode-tui/src/tui/ui_tests/tools.rs": 1352,
-    "src/cli/commands_tests.rs": 1274,
-    "tests/e2e/test_support/mod.rs": 1425
+    "crates/jcode-tui/src/tui/ui_tests/tools.rs": 1528,
+    "src/cli/commands_tests.rs": 1572,
+    "tests/e2e/test_support/mod.rs": 1428
   },
   "version": 1
 }

From 40ccf97af21457e1f32f9668864e65c1f63fc444 Mon Sep 17 00:00:00 2001
From: Alejandro Blanco-M <alecuba16@gmail.com>
Date: Sat, 19 Sep 2026 11:10:16 +0200
Subject: [PATCH 05/21] Remove dead linux-only helper orphaned by upstream
 notice shortening

Upstream 9bb6ccb81 removed the only caller of
linux_hotkey_target_description, leaving it dead under
cfg(target_os = "linux"). Not visible on macOS builds, but it fails
CI's ubuntu clippy gate (-D dead_code via -D warnings).
---
 crates/jcode-setup-hints/src/lib.rs | 19 -------------------
 1 file changed, 19 deletions(-)

diff --git a/crates/jcode-setup-hints/src/lib.rs b/crates/jcode-setup-hints/src/lib.rs
index a774434153..d2df02a68f 100644
--- a/crates/jcode-setup-hints/src/lib.rs
+++ b/crates/jcode-setup-hints/src/lib.rs
@@ -1503,25 +1503,6 @@ fn linux_hotkey_config_path(comp: linux_env::LinuxCompositor) -> Option<PathBuf>
     }
 }
 
-/// Human description of where the binds land, for the startup notice footer.
-#[cfg(target_os = "linux")]
-fn linux_hotkey_target_description(comp: linux_env::LinuxCompositor) -> String {
-    use linux_env::LinuxCompositor;
-    match comp {
-        LinuxCompositor::Gnome => "GNOME custom shortcuts (via dconf)".to_string(),
-        LinuxCompositor::Kde => "KDE global shortcuts (kglobalshortcutsrc)".to_string(),
-        LinuxCompositor::Cinnamon => "Cinnamon custom shortcuts (via dconf)".to_string(),
-        LinuxCompositor::Mate => "MATE custom shortcuts (via dconf)".to_string(),
-        LinuxCompositor::Xfce => "XFCE keyboard shortcuts (via xfconf)".to_string(),
-        other => {
-            let path = linux_hotkey_config_path(other)
-                .map(|p| p.display().to_string())
-                .unwrap_or_else(|| "its config".to_string());
-            format!("your {} config ({})", other.name(), path)
-        }
-    }
-}
-
 /// The sentinel that marks jcode's managed region in `path` for `comp`.
 #[cfg(target_os = "linux")]
 fn linux_hotkey_sentinel(comp: linux_env::LinuxCompositor) -> &'static str {

From 7973bde1005cf0777c64198d835f656603235cb3 Mon Sep 17 00:00:00 2001
From: Alejandro Blanco-M <alecuba16@gmail.com>
Date: Sat, 19 Sep 2026 11:18:29 +0200
Subject: [PATCH 06/21] Fix clippy 1.98 lints: needless_late_init,
 chunks_exact_to_as_chunks

CI's dtolnay/rust-toolchain@stable now resolves to 1.98.1, past the
1.96 the workspace was previously linted against. Two new findings:
- swarm_gallery.rs needless_late_init: convert 'used' to a let-if
- session_search_index.rs chunks_exact_to_as_chunks: as_chunks::<8>()
---
 .../jcode-app-core/src/tool/session_search_index.rs   | 11 ++++-------
 crates/jcode-tui-render/src/swarm_gallery.rs          |  9 ++++-----
 2 files changed, 8 insertions(+), 12 deletions(-)

diff --git a/crates/jcode-app-core/src/tool/session_search_index.rs b/crates/jcode-app-core/src/tool/session_search_index.rs
index 430d5314a1..959a92d053 100644
--- a/crates/jcode-app-core/src/tool/session_search_index.rs
+++ b/crates/jcode-app-core/src/tool/session_search_index.rs
@@ -298,13 +298,10 @@ impl TokenHashIndex {
         for (key, mtime_ms, size, overflow, token_count, word_count) in metas {
             let bytes = cursor.take(word_count * 8)?;
             let bits: Vec<u64> = bytes
-                .chunks_exact(8)
-                .map(|chunk| {
-                    u64::from_le_bytes([
-                        chunk[0], chunk[1], chunk[2], chunk[3], chunk[4], chunk[5], chunk[6],
-                        chunk[7],
-                    ])
-                })
+                .as_chunks::<8>()
+                .0
+                .iter()
+                .map(|chunk| u64::from_le_bytes(*chunk))
                 .collect();
             entries.push(IndexEntry {
                 key,
diff --git a/crates/jcode-tui-render/src/swarm_gallery.rs b/crates/jcode-tui-render/src/swarm_gallery.rs
index 2bbdb8aa21..ad41987bad 100644
--- a/crates/jcode-tui-render/src/swarm_gallery.rs
+++ b/crates/jcode-tui-render/src/swarm_gallery.rs
@@ -711,8 +711,7 @@ pub fn render_swarm_strip(
 
     let mut spans: Vec<Span<'static>> = lead;
     let mut task_used = 0usize;
-    let used: usize;
-    if shown == 0 && !chips.is_empty() {
+    let used: usize = if shown == 0 && !chips.is_empty() {
         // Degenerate width: show the first chip truncated.
         let budget = width.saturating_sub(lead_w + if show_tally { tail_w + gap } else { 0 });
         let c = &chips[0];
@@ -721,7 +720,7 @@ pub fn render_swarm_strip(
         let style = Style::default().fg(c.color);
         spans.push(Span::styled(format!("{} ", c.glyph), style));
         spans.push(Span::styled(name.clone(), style));
-        used = disp_w(&c.glyph) + 1 + disp_w(&name);
+        disp_w(&c.glyph) + 1 + disp_w(&name)
     } else {
         for (i, chip) in chips.iter().take(shown).enumerate() {
             if i > 0 {
@@ -758,8 +757,8 @@ pub fn render_swarm_strip(
                 Style::default().fg(rgb(140, 140, 150)),
             ));
         }
-        used = chips_used + task_used;
-    }
+        chips_used + task_used
+    };
 
     // ---- Right-align the tail (tally [+ hint]) ----
     if show_tally {

From 8b4d2c1ca2eaaaae90a1cab29ae2560950d58e71 Mon Sep 17 00:00:00 2001
From: Alejandro Blanco-M <alecuba16@gmail.com>
Date: Sat, 19 Sep 2026 11:29:51 +0200
Subject: [PATCH 07/21] Bump h2/rustls to fix RUSTSEC-2026-0258 and
 RUSTSEC-2026-0285

cargo audit found 2 unfixed vulnerabilities (h2 0.4.13, rustls
0.23.37) that fail CI's security preflight; both are patch-level
updates (h2 0.4.19, rustls 0.23.45 + rustls-webpki 0.103.15).
Upstream master carries the same advisories.
---
 Cargo.lock | 35 ++++++++++++++++++-----------------
 1 file changed, 18 insertions(+), 17 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index d41acbda6c..f63b7e2786 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -194,7 +194,7 @@ dependencies = [
  "objc2-foundation",
  "parking_lot",
  "percent-encoding",
- "windows-sys 0.60.2",
+ "windows-sys 0.59.0",
  "x11rb",
 ]
 
@@ -353,9 +353,9 @@ dependencies = [
 
 [[package]]
 name = "aws-lc-rs"
-version = "1.16.3"
+version = "1.18.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ec6fb3fe69024a75fa7e1bfb48aa6cf59706a101658ea01bfd33b2b248a038f"
+checksum = "b281d307588d634de920874890732659e2e7672f72b5e10e81badc1a8a83621e"
 dependencies = [
  "aws-lc-sys",
  "zeroize",
@@ -363,14 +363,15 @@ dependencies = [
 
 [[package]]
 name = "aws-lc-sys"
-version = "0.40.0"
+version = "0.45.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f50037ee5e1e41e7b8f9d161680a725bd1626cb6f8c7e901f91f942850852fe7"
+checksum = "9bff6c3b54fad79a2e60b8102caf565819711497c1f5f092f49508e2f5c31b27"
 dependencies = [
  "cc",
  "cmake",
  "dunce",
  "fs_extra",
+ "pkg-config",
 ]
 
 [[package]]
@@ -1894,7 +1895,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -2440,9 +2441,9 @@ dependencies = [
 
 [[package]]
 name = "h2"
-version = "0.4.13"
+version = "0.4.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f44da3a8150a6703ed5d34e164b875fd14c2cdab9af1252a9a1020bde2bdc54"
+checksum = "ef8e5e5a340588f4452631496976cf8636d4a7ecf600239fdc27615d2530bc16"
 dependencies = [
  "atomic-waker",
  "bytes",
@@ -5890,7 +5891,7 @@ dependencies = [
  "once_cell",
  "socket2",
  "tracing",
- "windows-sys 0.60.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -6492,14 +6493,14 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys 0.11.0",
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "rustls"
-version = "0.23.37"
+version = "0.23.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "758025cb5fccfd3bc2fd74708fd4682be41d99e5dff73c377c0646c6012c73a4"
+checksum = "0d41d731c7d2f962d1ccc364cec258de3c0e93b38c2fb3ba97ac74513048d634"
 dependencies = [
  "aws-lc-rs",
  "log",
@@ -6551,7 +6552,7 @@ dependencies = [
  "security-framework",
  "security-framework-sys",
  "webpki-root-certs",
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -6562,9 +6563,9 @@ checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f"
 
 [[package]]
 name = "rustls-webpki"
-version = "0.103.13"
+version = "0.103.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61c429a8649f110dddef65e2a5ad240f747e85f7758a6bccc7e5777bd33f756e"
+checksum = "f3c3cf1d8b1e7d4927e2d154c3fcb02979afb9939629c62cd9048d4f07b60ac2"
 dependencies = [
  "aws-lc-rs",
  "ring",
@@ -7226,7 +7227,7 @@ dependencies = [
  "getrandom 0.3.4",
  "once_cell",
  "rustix 1.1.3",
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -8639,7 +8640,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]

From e66680234b9820ebf05efa521d652bbcb71b163e Mon Sep 17 00:00:00 2001
From: Alejandro Blanco-M <alecuba16@gmail.com>
Date: Sat, 19 Sep 2026 15:50:15 +0200
Subject: [PATCH 08/21] ci: merge duplicate workflow env maps (fixes #1191)

---
 .github/workflows/ci.yml | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index a285b327b1..73d397e16a 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,8 +1,5 @@
 name: CI
 
-env:
-  JCODE_CI: "1"
-
 on:
   push:
     branches: [main, master]
@@ -14,6 +11,7 @@ concurrency:
   cancel-in-progress: true
 
 env:
+  JCODE_CI: "1"
   CARGO_TERM_COLOR: always
   SCCACHE_GHA_ENABLED: "true"
 

From 08502aba2ea19136b541479cbd07b8ab8bb7be71 Mon Sep 17 00:00:00 2001
From: Alejandro Blanco-M <alecuba16@gmail.com>
Date: Sat, 19 Sep 2026 15:53:31 +0200
Subject: [PATCH 09/21] ci: retrigger workflows after enabling Actions


From d831b057fcab3807be8c278f835dce15fa409ad8 Mon Sep 17 00:00:00 2001
From: Alejandro Blanco-M <alecuba16@gmail.com>
Date: Sat, 19 Sep 2026 15:54:16 +0200
Subject: [PATCH 10/21] ci: retrigger after allowing marketplace actions


From c15a52744c3dc9536980f50c37b74e40d5e5d43a Mon Sep 17 00:00:00 2001
From: Alejandro Blanco-M <alecuba16@gmail.com>
Date: Sat, 19 Sep 2026 15:59:47 +0200
Subject: [PATCH 11/21] ci: make SSH deploy-key steps optional for forks
 without the secret

---
 .github/workflows/ci.yml | 20 ++++++++++++++++----
 1 file changed, 16 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 73d397e16a..6a4a0b6049 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -28,8 +28,11 @@ jobs:
 
       - name: Configure SSH for cargo git dependencies
         uses: webfactory/ssh-agent@v0.9.0
+        if: env.DEPLOY_KEY != ''
+        env:
+          DEPLOY_KEY: ${{ secrets.DEPLOY_KEY }}
         with:
-          ssh-private-key: ${{ secrets.DEPLOY_KEY }}
+          ssh-private-key: ${{ env.DEPLOY_KEY }}
 
       - uses: dtolnay/rust-toolchain@stable
         with:
@@ -154,8 +157,11 @@ jobs:
 
       - name: Configure SSH for cargo git dependencies
         uses: webfactory/ssh-agent@v0.9.0
+        if: env.DEPLOY_KEY != ''
+        env:
+          DEPLOY_KEY: ${{ secrets.DEPLOY_KEY }}
         with:
-          ssh-private-key: ${{ secrets.DEPLOY_KEY }}
+          ssh-private-key: ${{ env.DEPLOY_KEY }}
 
       - uses: dtolnay/rust-toolchain@stable
         with:
@@ -394,8 +400,11 @@ jobs:
 
       - name: Configure SSH for cargo git dependencies
         uses: webfactory/ssh-agent@v0.9.0
+        if: env.DEPLOY_KEY != ''
+        env:
+          DEPLOY_KEY: ${{ secrets.DEPLOY_KEY }}
         with:
-          ssh-private-key: ${{ secrets.DEPLOY_KEY }}
+          ssh-private-key: ${{ env.DEPLOY_KEY }}
 
       - uses: ilammy/msvc-dev-cmd@v1
         with:
@@ -647,8 +656,11 @@ jobs:
 
       - name: Configure SSH for cargo git dependencies
         uses: webfactory/ssh-agent@v0.9.0
+        if: env.DEPLOY_KEY != ''
+        env:
+          DEPLOY_KEY: ${{ secrets.DEPLOY_KEY }}
         with:
-          ssh-private-key: ${{ secrets.DEPLOY_KEY }}
+          ssh-private-key: ${{ env.DEPLOY_KEY }}
 
       - uses: dtolnay/rust-toolchain@stable
         with:

From 7b3d0921ef637ff2a2f2cdfbe4d079eee0dc5d69 Mon Sep 17 00:00:00 2001
From: Alejandro Blanco-M <alecuba16@gmail.com>
Date: Sat, 19 Sep 2026 18:16:20 +0200
Subject: [PATCH 12/21] fix(review): strip reasoning markup from judge
 transcripts

637b29794 made render_messages inline persisted reasoning when the
display config asks for it, leaking private reasoning into the
transcript prepared for spawned judge sessions. Filter
REASONING_SENTINEL lines from the judge transcript so review judges
see the same content the user saw.
---
 .../jcode-tui/src/tui/app/commands_review.rs  | 24 +++++++++++++++++--
 1 file changed, 22 insertions(+), 2 deletions(-)

diff --git a/crates/jcode-tui/src/tui/app/commands_review.rs b/crates/jcode-tui/src/tui/app/commands_review.rs
index 2c1292a7d4..508dfd4383 100644
--- a/crates/jcode-tui/src/tui/app/commands_review.rs
+++ b/crates/jcode-tui/src/tui/app/commands_review.rs
@@ -170,6 +170,26 @@ fn judge_visible_tool_summary(tool: &ToolCall) -> Option<String> {
     }
 }
 
+/// Strip re-rendered reasoning markup from a rendered message body.
+///
+/// `render_messages` inlines persisted reasoning (when the user's display
+/// config shows thinking) as `*{sentinel}...{sentinel}*` lines prefixed to the
+/// assistant text. The judge transcript is a user-visible mirror: private
+/// reasoning must never reach it, regardless of the local display preference.
+fn strip_reasoning_markup(content: &str) -> String {
+    content
+        .lines()
+        .filter(|line| {
+            !line
+                .trim_end()
+                .starts_with(&format!("*{}", jcode_tui_markdown::REASONING_SENTINEL))
+        })
+        .collect::<Vec<_>>()
+        .join("\n")
+        .trim()
+        .to_string()
+}
+
 fn build_judge_visible_transcript_messages(parent_session: &Session) -> Vec<StoredMessage> {
     let mut transcript = Vec::new();
 
@@ -179,12 +199,12 @@ fn build_judge_visible_transcript_messages(parent_session: &Session) -> Vec<Stor
                 if !rendered.content.trim().is_empty() {
                     transcript.push(judge_transcript_text_message(
                         Role::User,
-                        rendered.content.trim().to_string(),
+                        strip_reasoning_markup(&rendered.content),
                     ));
                 }
             }
             "assistant" => {
-                let mut text = rendered.content.trim().to_string();
+                let mut text = strip_reasoning_markup(&rendered.content);
                 if !rendered.tool_calls.is_empty() {
                     let visible_tools = rendered
                         .tool_calls

From 1ee1d06df778b7a28b25df99715be7ebc80d0615 Mon Sep 17 00:00:00 2001
From: Alejandro Blanco-M <alecuba16@gmail.com>
Date: Sat, 19 Sep 2026 18:16:22 +0200
Subject: [PATCH 13/21] fix(tui): wrap long plan intentions instead of
 truncating them

The intent assessment line ran through todo_card_line, which clips to
the card width with an ellipsis. A long plan intention therefore showed
only its first fragment even on wide terminals, and the batched retry
card test failed on upstream for the same reason. Wrap the intention
across card rows like the other todo detail fields; keep the single
clipped line for compact cards.
---
 crates/jcode-tui/src/tui/ui_messages.rs | 60 ++++++++++++++++++++-----
 1 file changed, 49 insertions(+), 11 deletions(-)

diff --git a/crates/jcode-tui/src/tui/ui_messages.rs b/crates/jcode-tui/src/tui/ui_messages.rs
index d455ce4f8d..7ed35b3183 100644
--- a/crates/jcode-tui/src/tui/ui_messages.rs
+++ b/crates/jcode-tui/src/tui/ui_messages.rs
@@ -1455,18 +1455,56 @@ fn push_todo_plan_details(
             crate::todo::IntentUnderstanding::Clear
             | crate::todo::IntentUnderstanding::Complete => todo_score_color(),
         };
-        let mut spans = vec![
-            Span::styled("Intent ", Style::default().fg(todo_label_color())),
-            Span::styled(state.as_str().to_string(), Style::default().fg(state_color)),
-            Span::styled(": ", Style::default().fg(todo_label_color())),
-        ];
-        if let Some(intention) = intention {
-            spans.push(Span::styled(
-                intention.to_string(),
-                Style::default().fg(todo_meta_color()),
-            ));
+        let intention_text = intention.unwrap_or_default();
+        if !compact_details && !intention_text.is_empty() {
+            // A long plan intention must stay readable, not get clipped to an
+            // ellipsis: wrap it across card rows like the other detail fields.
+            let prefix_width = "Intent ".width() + state.as_str().width() + ": ".width();
+            let available = inner_width.saturating_sub(prefix_width).max(1);
+            for (index, chunk) in wrap_todo_detail(intention_text, available)
+                .into_iter()
+                .enumerate()
+            {
+                let mut line_spans = Vec::new();
+                if index == 0 {
+                    line_spans.push(Span::styled(
+                        "Intent ",
+                        Style::default().fg(todo_label_color()),
+                    ));
+                    line_spans.push(Span::styled(
+                        state.as_str().to_string(),
+                        Style::default().fg(state_color),
+                    ));
+                    line_spans.push(Span::styled(
+                        ": ".to_string(),
+                        Style::default().fg(todo_label_color()),
+                    ));
+                } else {
+                    line_spans.push(Span::styled(
+                        " ".repeat(prefix_width),
+                        Style::default(),
+                    ));
+                }
+                line_spans.push(Span::styled(
+                    chunk,
+                    Style::default().fg(todo_meta_color()),
+                ));
+                lines.push(todo_card_line(line_spans, base_indent, inner_width));
+            }
+        } else {
+            let mut spans = vec![
+                Span::styled("Intent ", Style::default().fg(todo_label_color())),
+                Span::styled(state.as_str().to_string(), Style::default().fg(state_color)),
+                Span::styled(": ", Style::default().fg(todo_label_color())),
+            ];
+            if let Some(intention) = intention {
+                spans.push(Span::styled(
+                    intention.to_string(),
+                    Style::default().fg(todo_meta_color()),
+                ));
+            }
+            lines.push(todo_card_line(spans, base_indent, inner_width));
         }
-        lines.push(todo_card_line(spans, base_indent, inner_width));
     } else if let Some(intention) = intention {
         push_todo_detail(
             lines,

From 416bee7860f77b765364380d602cbf870112cfb3 Mon Sep 17 00:00:00 2001
From: Alejandro Blanco-M <alecuba16@gmail.com>
Date: Sat, 19 Sep 2026 18:16:23 +0200
Subject: [PATCH 14/21] test(tui): refresh expectations for upstream behavior
 changes
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Nine tests asserted behavior that later product commits replaced; all
nine also fail on upstream master. Each now tests the current behavior:

- account shorthand/logout: capture assigned animal labels (b28720562
  canonicalized upsert labels)
- recent project review: notice reads 'No active Git repository
  found' (e90512dd6)
- drag-copy: selection highlight stays with 'Copied selection ·
  highlight remains visible' notice (c7afd6620)
- gate digest: completed cycle queues the final-response continuation
  (1bd235b5f)
- improve mode persist: bare sessions skip lazy save (9e8d6e13b)
- onboarding banner: 'Start in the current directory' label moved the
  right-aligned action; assert bottom-right quadrant by proportions
  (dbd903a84)
---
 .../app/tests/commands_accounts_02/part_01.rs |  8 +++++---
 .../app/tests/commands_accounts_02/part_02.rs |  3 +++
 .../src/tui/app/tests/input_copy_selection.rs | 15 ++++++++++-----
 .../src/tui/app/tests/onboarding_flow.rs      |  2 +-
 .../tui/app/tests/remote_events_reload_05.rs  | 19 ++++++++++++++++---
 .../tui/app/tests/scroll_copy_02/part_01.rs   |  5 ++++-
 .../app/tests/state_model_poke_02/part_01.rs  | 10 +++++++---
 .../jcode-tui/src/tui/session_picker_tests.rs |  3 ++-
 8 files changed, 48 insertions(+), 17 deletions(-)

diff --git a/crates/jcode-tui/src/tui/app/tests/commands_accounts_02/part_01.rs b/crates/jcode-tui/src/tui/app/tests/commands_accounts_02/part_01.rs
index c386372f2b..5f6ef6f656 100644
--- a/crates/jcode-tui/src/tui/app/tests/commands_accounts_02/part_01.rs
+++ b/crates/jcode-tui/src/tui/app/tests/commands_accounts_02/part_01.rs
@@ -537,7 +537,9 @@ fn test_account_switch_shorthand_switches_openai_account_by_label() {
     with_temp_jcode_home(|| {
         let now_ms = chrono::Utc::now().timestamp_millis();
 
-        crate::auth::codex::upsert_account(crate::auth::codex::OpenAiAccount {
+        // Upserting a new account canonicalizes its label (animal naming,
+        // e.g. `openai-otter`), so capture the assigned label and switch by it.
+        let assigned_label = crate::auth::codex::upsert_account(crate::auth::codex::OpenAiAccount {
             label: "openai2".to_string(),
             access_token: "acc".to_string(),
             refresh_token: "ref".to_string(),
@@ -551,12 +553,12 @@ fn test_account_switch_shorthand_switches_openai_account_by_label() {
         let mut app = create_test_app();
         let rt = tokio::runtime::Runtime::new().unwrap();
         rt.block_on(async {
-            app.input = "/account switch openai2".to_string();
+            app.input = format!("/account switch {assigned_label}");
             app.submit_input();
 
             assert_eq!(
                 crate::auth::codex::active_account_label().as_deref(),
-                Some("openai-1")
+                Some(assigned_label.as_str())
             );
         });
     });
diff --git a/crates/jcode-tui/src/tui/app/tests/commands_accounts_02/part_02.rs b/crates/jcode-tui/src/tui/app/tests/commands_accounts_02/part_02.rs
index 1c06223412..b583981ba5 100644
--- a/crates/jcode-tui/src/tui/app/tests/commands_accounts_02/part_02.rs
+++ b/crates/jcode-tui/src/tui/app/tests/commands_accounts_02/part_02.rs
@@ -3,6 +3,9 @@ fn test_improve_mode_persists_in_session_file() {
     with_temp_jcode_home(|| {
         let mut session = crate::session::Session::create(None, None);
         session.improve_mode = Some(crate::session::SessionImproveMode::ImprovePlan);
+        // Bare sessions without a visible message or title are deliberately
+        // not persisted (lazy-save guard), so give this one an explicit title.
+        session.title = Some("improve-mode persistence check".to_string());
         let session_id = session.id.clone();
         session.save().expect("save session");
 
diff --git a/crates/jcode-tui/src/tui/app/tests/input_copy_selection.rs b/crates/jcode-tui/src/tui/app/tests/input_copy_selection.rs
index fa9bf512e7..ae19677593 100644
--- a/crates/jcode-tui/src/tui/app/tests/input_copy_selection.rs
+++ b/crates/jcode-tui/src/tui/app/tests/input_copy_selection.rs
@@ -99,10 +99,13 @@ fn test_input_composer_drag_selects_and_copies_typed_text() {
 
     let copied = drag_copy(&mut app, start, end);
     assert_eq!(copied, "select this draft");
-    assert_eq!(app.status_notice(), Some("Copied selection".to_string()));
-    // Selection state is cleared after the copy.
-    assert!(app.copy_selection_anchor.is_none());
-    assert!(app.copy_selection_cursor.is_none());
+    assert_eq!(
+        app.status_notice().as_deref(),
+        Some("Copied selection · highlight remains visible")
+    );
+    // Drag-to-copy keeps the highlight visible until the next click.
+    assert!(app.copy_selection_anchor.is_some());
+    assert!(app.copy_selection_cursor.is_some());
 }
 
 #[test]
@@ -411,7 +414,9 @@ fn test_input_composer_drag_then_release_copies_via_full_mouse_path() {
     assert!(
         matches!(
             app.status_notice().as_deref(),
-            Some("Copied selection") | Some("Failed to copy selection")
+            Some("Copied selection")
+                | Some("Copied selection · highlight remains visible")
+                | Some("Failed to copy selection")
         ),
         "drag release over the composer must attempt a copy, got {:?}",
         app.status_notice()
diff --git a/crates/jcode-tui/src/tui/app/tests/onboarding_flow.rs b/crates/jcode-tui/src/tui/app/tests/onboarding_flow.rs
index afbdc1d3de..156e759bd8 100644
--- a/crates/jcode-tui/src/tui/app/tests/onboarding_flow.rs
+++ b/crates/jcode-tui/src/tui/app/tests/onboarding_flow.rs
@@ -1674,7 +1674,7 @@ fn recent_project_review_falls_back_cleanly_when_no_repo_is_known() {
     assert!(app.queued_messages.is_empty());
     assert!(matches!(app.onboarding_phase(), Some(OnboardingPhase::Suggestions)));
     assert!(app.status_notice.as_ref().is_some_and(|(notice, _)| {
-        notice.contains("No recent Git repository found")
+        notice.contains("No active Git repository found")
     }));
 }
 
diff --git a/crates/jcode-tui/src/tui/app/tests/remote_events_reload_05.rs b/crates/jcode-tui/src/tui/app/tests/remote_events_reload_05.rs
index 66fb24e8fb..804d37803b 100644
--- a/crates/jcode-tui/src/tui/app/tests/remote_events_reload_05.rs
+++ b/crates/jcode-tui/src/tui/app/tests/remote_events_reload_05.rs
@@ -821,17 +821,30 @@ fn test_gate_digest_is_delivered_at_turn_end_and_rearms_next_cycle() {
                 .is_empty()
         );
 
-        // Simulate the turn running, then the cycle completing.
+        // Simulate the turn running, then the cycle completing. A cleanly completed
+        // cycle hands off to one final-answer continuation before the next
+        // digest can be delivered (see 1bd235b5f).
         app.queued_messages.clear();
         app.pending_queued_dispatch = false;
         assert!(
-            !app.schedule_auto_poke_followup_if_needed(),
-            "with nothing left outstanding the cycle should finish"
+            app.schedule_auto_poke_followup_if_needed(),
+            "a finished cycle should request one final-answer turn"
+        );
+        assert_eq!(
+            app.queued_messages,
+            vec![crate::todo::TODO_FINAL_RESPONSE_CONTINUATION_MESSAGE.to_string()]
         );
         assert!(
             !app.todo_gate_digest_delivered,
             "a finished cycle must re-arm the review for later work"
         );
+        // The final-answer turn itself must not enqueue another final answer.
+        app.queued_messages.clear();
+        app.pending_queued_dispatch = false;
+        assert!(
+            !app.schedule_auto_poke_followup_if_needed(),
+            "the final-answer turn must not loop"
+        );
     });
 }
 
diff --git a/crates/jcode-tui/src/tui/app/tests/scroll_copy_02/part_01.rs b/crates/jcode-tui/src/tui/app/tests/scroll_copy_02/part_01.rs
index 37e1b8808d..5d7667f653 100644
--- a/crates/jcode-tui/src/tui/app/tests/scroll_copy_02/part_01.rs
+++ b/crates/jcode-tui/src/tui/app/tests/scroll_copy_02/part_01.rs
@@ -1478,6 +1478,9 @@ fn test_changelog_overlay_mouse_drag_release_copies_text() {
     // in the test environment, but the selection path must have run).
     assert!(matches!(
         app.status_notice().as_deref(),
-        Some("Copied selection") | Some("Failed to copy selection") | Some("Selection is empty")
+        Some("Copied selection")
+            | Some("Copied selection · highlight remains visible")
+            | Some("Failed to copy selection")
+            | Some("Selection is empty")
     ));
 }
diff --git a/crates/jcode-tui/src/tui/app/tests/state_model_poke_02/part_01.rs b/crates/jcode-tui/src/tui/app/tests/state_model_poke_02/part_01.rs
index 7667e827c7..970ba2382f 100644
--- a/crates/jcode-tui/src/tui/app/tests/state_model_poke_02/part_01.rs
+++ b/crates/jcode-tui/src/tui/app/tests/state_model_poke_02/part_01.rs
@@ -1004,8 +1004,11 @@ fn test_top_level_command_suggestions_include_all_non_hidden_commands() {
 #[test]
 fn test_logout_clear_anthropic_accounts_removes_all_accounts_once() {
     with_temp_jcode_home(|| {
+        // Upsert canonicalizes labels with animal names (claude-otter,
+        // claude-fox, claude-panda), so collect the assigned labels.
+        let mut labels_assigned: Vec<String> = Vec::new();
         for index in 1..=3 {
-            crate::auth::claude::upsert_account(crate::auth::claude::AnthropicAccount {
+            let label = crate::auth::claude::upsert_account(crate::auth::claude::AnthropicAccount {
                 label: format!("requested-{index}"),
                 access: format!("access-{index}"),
                 refresh: format!("refresh-{index}"),
@@ -1015,15 +1018,16 @@ fn test_logout_clear_anthropic_accounts_removes_all_accounts_once() {
                 scopes: Vec::new(),
             })
             .unwrap();
+            labels_assigned.push(label);
         }
-        crate::auth::claude::set_active_account("claude-3").unwrap();
+        crate::auth::claude::set_active_account(&labels_assigned[2]).unwrap();
 
         let labels: Vec<_> = crate::auth::claude::list_accounts()
             .unwrap()
             .into_iter()
             .map(|account| account.label)
             .collect();
-        assert_eq!(labels, vec!["claude-1", "claude-2", "claude-3"]);
+        assert_eq!(labels, labels_assigned);
 
         assert_eq!(crate::auth::claude::clear_accounts().unwrap(), 3);
         assert!(crate::auth::claude::list_accounts().unwrap().is_empty());
diff --git a/crates/jcode-tui/src/tui/session_picker_tests.rs b/crates/jcode-tui/src/tui/session_picker_tests.rs
index 95fe9db360..6874254f43 100644
--- a/crates/jcode-tui/src/tui/session_picker_tests.rs
+++ b/crates/jcode-tui/src/tui/session_picker_tests.rs
@@ -1426,7 +1426,8 @@ fn onboarding_banner_renders_prompt_and_both_action_rows() {
         "suggested prompt should span the visual center: {lines:#?}"
     );
     assert!(
-        start_y >= buffer.area.height as usize - 3 && start_x >= 95,
+        start_y >= buffer.area.height as usize - 3
+            && start_x >= buffer.area.width as usize / 2,
         "blank-session action should stay secondary in the bottom-right: {lines:#?}"
     );
 }

From 627b605b8273da672aab10cb4093e58a01ba80e0 Mon Sep 17 00:00:00 2001
From: Alejandro Blanco-M <alecuba16@gmail.com>
Date: Sat, 19 Sep 2026 18:20:46 +0200
Subject: [PATCH 15/21] style: cargo fmt

---
 crates/jcode-tui/src/tui/session_picker_tests.rs |  3 +--
 crates/jcode-tui/src/tui/ui_messages.rs          | 10 ++--------
 2 files changed, 3 insertions(+), 10 deletions(-)

diff --git a/crates/jcode-tui/src/tui/session_picker_tests.rs b/crates/jcode-tui/src/tui/session_picker_tests.rs
index 6874254f43..2ab6387b01 100644
--- a/crates/jcode-tui/src/tui/session_picker_tests.rs
+++ b/crates/jcode-tui/src/tui/session_picker_tests.rs
@@ -1426,8 +1426,7 @@ fn onboarding_banner_renders_prompt_and_both_action_rows() {
         "suggested prompt should span the visual center: {lines:#?}"
     );
     assert!(
-        start_y >= buffer.area.height as usize - 3
-            && start_x >= buffer.area.width as usize / 2,
+        start_y >= buffer.area.height as usize - 3 && start_x >= buffer.area.width as usize / 2,
         "blank-session action should stay secondary in the bottom-right: {lines:#?}"
     );
 }
diff --git a/crates/jcode-tui/src/tui/ui_messages.rs b/crates/jcode-tui/src/tui/ui_messages.rs
index 7ed35b3183..0c716c9c27 100644
--- a/crates/jcode-tui/src/tui/ui_messages.rs
+++ b/crates/jcode-tui/src/tui/ui_messages.rs
@@ -1480,15 +1480,9 @@ fn push_todo_plan_details(
                         Style::default().fg(todo_label_color()),
                     ));
                 } else {
-                    line_spans.push(Span::styled(
-                        " ".repeat(prefix_width),
-                        Style::default(),
-                    ));
+                    line_spans.push(Span::styled(" ".repeat(prefix_width), Style::default()));
                 }
-                line_spans.push(Span::styled(
-                    chunk,
-                    Style::default().fg(todo_meta_color()),
-                ));
+                line_spans.push(Span::styled(chunk, Style::default().fg(todo_meta_color())));
                 lines.push(todo_card_line(line_spans, base_indent, inner_width));
             }
         } else {

From b99abe5a82a70589778d299c47aa443d4d202da5 Mon Sep 17 00:00:00 2001
From: Alejandro Blanco-M <alecuba16@gmail.com>
Date: Sat, 19 Sep 2026 18:33:46 +0200
Subject: [PATCH 16/21] refactor(tui): split todo card rendering into its own
 module

ui_messages.rs exceeded the code-size budget after the intent-wrap
fix. Move the contiguous todo-card family (todo_card_line through
render_todo_card_item_line, ~850 lines) to ui_messages_todo.rs,
included as a child of the messages module. ui_messages.rs drops
4478 -> 3660 LOC; the new file is well under the threshold.

Also gates the intent wrap to Clear/Complete understanding so the
one-line ellipsis contract for partial/uncertain intents is kept.
---
 crates/jcode-tui/src/tui/ui_messages.rs      | 866 +-----------------
 crates/jcode-tui/src/tui/ui_messages_todo.rs | 867 +++++++++++++++++++
 2 files changed, 877 insertions(+), 856 deletions(-)
 create mode 100644 crates/jcode-tui/src/tui/ui_messages_todo.rs

diff --git a/crates/jcode-tui/src/tui/ui_messages.rs b/crates/jcode-tui/src/tui/ui_messages.rs
index 0c716c9c27..9477bfaecc 100644
--- a/crates/jcode-tui/src/tui/ui_messages.rs
+++ b/crates/jcode-tui/src/tui/ui_messages.rs
@@ -7,8 +7,18 @@ use crate::message::{
     parse_background_task_progress_notification_markdown, strip_ansi_escape_sequences,
 };
 pub(super) use cache_support::get_cached_message_lines;
+
+#[path = "ui_messages_todo.rs"]
+mod todo_card;
 use cache_support::{centered_wrap_width, left_pad_lines_for_centered_mode};
 use std::borrow::Cow;
+#[cfg(test)]
+pub(crate) use todo_card::render_todo_goal_updates;
+use todo_card::{
+    push_todo_goal_details, push_todo_plan_details, render_todo_assessment_updates,
+    render_todo_card_item_line, render_todo_goal_header, render_todo_status_header,
+    todo_card_goal_for_group, todo_card_line,
+};
 use unicode_width::UnicodeWidthStr;
 
 const MAX_INLINE_DIFF_LINES: usize = 12;
@@ -1185,862 +1195,6 @@ pub(crate) fn render_todos_message(
     lines
 }
 
-fn todo_card_line(
-    spans: Vec<Span<'static>>,
-    base_indent: &str,
-    inner_width: usize,
-) -> Line<'static> {
-    let mut prefixed = vec![Span::raw(base_indent.to_string())];
-    prefixed.extend(spans);
-    super::truncate_line_with_ellipsis_to_width(
-        &Line::from(prefixed),
-        inner_width.saturating_add(base_indent.width()),
-    )
-}
-
-fn todo_card_goal_for_group<'a>(
-    goals: &'a [crate::todo::TodoGoal],
-    group: Option<&str>,
-) -> Option<&'a crate::todo::TodoGoal> {
-    let key = group.map(str::trim).filter(|value| !value.is_empty());
-    goals.iter().find(|goal| {
-        goal.group
-            .as_deref()
-            .map(str::trim)
-            .filter(|value| !value.is_empty())
-            == key
-    })
-}
-
-fn todo_goal_score_spans(goal: &crate::todo::TodoGoal) -> Vec<Span<'static>> {
-    let mut spans = Vec::new();
-    let mut states: Vec<(&str, String, Color)> = Vec::new();
-    if !crate::todo::feedback_loop_passes(goal.closed_feedback_loop) {
-        let (state, color) = goal.closed_feedback_loop.map_or_else(
-            || ("missing".to_string(), todo_failure_color()),
-            |state| {
-                let color = if state <= crate::todo::FeedbackLoopState::Weak {
-                    todo_failure_color()
-                } else {
-                    todo_warning_color()
-                };
-                (state.as_str().to_string(), color)
-            },
-        );
-        states.push(("Closed feedback loop", state, color));
-    }
-    if !crate::todo::feedback_loop_relevance_passes(goal) {
-        let (state, color) = goal.feedback_loop_relevance.map_or_else(
-            || ("missing".to_string(), todo_failure_color()),
-            |state| {
-                let color = if state == crate::todo::FeedbackLoopRelevance::Indirect {
-                    todo_failure_color()
-                } else {
-                    todo_warning_color()
-                };
-                (state.as_str().to_string(), color)
-            },
-        );
-        states.push(("Relevance", state, color));
-    }
-    if !crate::todo::feedback_loop_coverage_passes(goal) {
-        let (state, color) = goal.feedback_loop_coverage.map_or_else(
-            || ("missing".to_string(), todo_failure_color()),
-            |state| {
-                let color = if state == crate::todo::FeedbackLoopCoverage::Narrow {
-                    todo_failure_color()
-                } else {
-                    todo_warning_color()
-                };
-                (state.as_str().to_string(), color)
-            },
-        );
-        states.push(("Coverage", state, color));
-    }
-    if !crate::todo::feedback_loop_traceability_passes(goal) {
-        let (state, color) = goal.feedback_loop_traceability.map_or_else(
-            || ("missing".to_string(), todo_failure_color()),
-            |state| {
-                let color = if state == crate::todo::FeedbackLoopTraceability::Unmapped {
-                    todo_failure_color()
-                } else {
-                    todo_warning_color()
-                };
-                (state.as_str().to_string(), color)
-            },
-        );
-        states.push(("Traceability", state, color));
-    }
-
-    if states.is_empty() {
-        spans.push(Span::styled(
-            "✓ All quality gates passing",
-            Style::default().fg(todo_score_color()),
-        ));
-    }
-
-    for (index, (label, state, color)) in states.into_iter().enumerate() {
-        if index > 0 {
-            spans.push(Span::styled(" · ", Style::default().fg(dim_color())));
-        }
-        spans.push(Span::styled(
-            format!("{} ", label),
-            Style::default().fg(todo_label_color()),
-        ));
-        spans.push(Span::styled(state, Style::default().fg(color)));
-    }
-
-    // Delivery is progress toward the outcome, not a quality gate. Keep it
-    // visible and visually separate from failures so it cannot read as one.
-    if let Some(state) = goal.delivery_state {
-        if !spans.is_empty() {
-            spans.push(Span::styled(" · ", Style::default().fg(dim_color())));
-        }
-        spans.push(Span::styled(
-            "Delivery ",
-            Style::default().fg(todo_label_color()),
-        ));
-        let color = if state >= crate::todo::DeliveryState::WorkflowValidated {
-            todo_score_color()
-        } else if state == crate::todo::DeliveryState::Integrated {
-            todo_warning_color()
-        } else {
-            todo_failure_color()
-        };
-        spans.push(Span::styled(
-            state.as_str().to_string(),
-            Style::default().fg(color),
-        ));
-    }
-    spans
-}
-
-fn push_todo_status_pips<'a>(
-    spans: &mut Vec<Span<'static>>,
-    todos: impl IntoIterator<Item = &'a crate::todo::TodoItem>,
-    max_pips: usize,
-) {
-    let (completed, in_progress, total) =
-        todos
-            .into_iter()
-            .fold((0usize, 0usize, 0usize), |counts, todo| {
-                (
-                    counts.0 + usize::from(todo.status == "completed"),
-                    counts.1 + usize::from(todo.status == "in_progress"),
-                    counts.2 + 1,
-                )
-            });
-    if total == 0 || max_pips == 0 {
-        return;
-    }
-
-    let (done_pips, active_pips, open_pips) = if total <= max_pips.max(12) {
-        (
-            completed,
-            in_progress,
-            total.saturating_sub(completed + in_progress),
-        )
-    } else {
-        let scale =
-            |count: usize| ((count as f64 / total as f64) * max_pips as f64).round() as usize;
-        let mut done = scale(completed);
-        let mut active = scale(in_progress);
-        if completed > 0 && done == 0 {
-            done = 1;
-        }
-        if in_progress > 0 && active == 0 {
-            active = 1;
-        }
-        done = done.min(max_pips);
-        active = active.min(max_pips.saturating_sub(done));
-        (done, active, max_pips.saturating_sub(done + active))
-    };
-
-    for _ in 0..done_pips {
-        spans.push(Span::styled("●", Style::default().fg(rgb(100, 180, 100))));
-    }
-    for _ in 0..active_pips {
-        spans.push(Span::styled("●", Style::default().fg(asap_color())));
-    }
-    for _ in 0..open_pips {
-        spans.push(Span::styled("○", Style::default().fg(rgb(90, 90, 105))));
-    }
-}
-
-fn render_todo_status_header<'a>(
-    todos: impl IntoIterator<Item = &'a crate::todo::TodoItem>,
-    base_indent: &str,
-    inner_width: usize,
-) -> Line<'static> {
-    let mut spans = Vec::new();
-    push_todo_status_pips(&mut spans, todos, inner_width);
-    todo_card_line(spans, base_indent, inner_width)
-}
-
-fn render_todo_goal_header(
-    label: &str,
-    todos: &[&crate::todo::TodoItem],
-    base_indent: &str,
-    inner_width: usize,
-) -> Line<'static> {
-    let label_width = label.width();
-    let mut spans = vec![Span::styled(
-        label.to_string(),
-        Style::default().fg(todo_group_color()).bold(),
-    )];
-    spans.push(Span::raw("  "));
-    push_todo_status_pips(
-        &mut spans,
-        todos.iter().copied(),
-        inner_width.saturating_sub(label_width + 2),
-    );
-    todo_card_line(spans, base_indent, inner_width)
-}
-
-fn wrap_todo_detail(value: &str, width: usize) -> Vec<String> {
-    let width = width.max(1);
-    let mut chunks = Vec::new();
-    let mut current = String::new();
-
-    for word in value.split_whitespace() {
-        let word_width = word.width();
-        if !current.is_empty() && current.width() + 1 + word_width <= width {
-            current.push(' ');
-            current.push_str(word);
-            continue;
-        }
-        if current.is_empty() && word_width <= width {
-            current.push_str(word);
-            continue;
-        }
-        if !current.is_empty() {
-            chunks.push(std::mem::take(&mut current));
-        }
-        if word_width <= width {
-            current.push_str(word);
-            continue;
-        }
-        let mut word_chunks = split_by_display_width(word, width).into_iter().peekable();
-        while let Some(chunk) = word_chunks.next() {
-            if word_chunks.peek().is_some() {
-                chunks.push(chunk);
-            } else {
-                current = chunk;
-            }
-        }
-    }
-    if !current.is_empty() {
-        chunks.push(current);
-    }
-    chunks
-}
-
-/// Plan-level assessment lines shown once above the todo groups.
-fn push_todo_plan_details(
-    lines: &mut Vec<Line<'static>>,
-    plan: &crate::todo::TodoPlan,
-    base_indent: &str,
-    inner_width: usize,
-    compact_details: bool,
-) {
-    let intention = plan
-        .user_intention
-        .as_deref()
-        .map(str::trim)
-        .filter(|value| !value.is_empty());
-    if let Some(state) = plan.understands_user_intent {
-        let state_color = match state {
-            crate::todo::IntentUnderstanding::Uncertain => todo_failure_color(),
-            crate::todo::IntentUnderstanding::Partial => todo_warning_color(),
-            crate::todo::IntentUnderstanding::Clear
-            | crate::todo::IntentUnderstanding::Complete => todo_score_color(),
-        };
-        let intention_text = intention.unwrap_or_default();
-        if !compact_details && !intention_text.is_empty() {
-            // A long plan intention must stay readable, not get clipped to an
-            // ellipsis: wrap it across card rows like the other detail fields.
-            let prefix_width = "Intent ".width() + state.as_str().width() + ": ".width();
-            let available = inner_width.saturating_sub(prefix_width).max(1);
-            for (index, chunk) in wrap_todo_detail(intention_text, available)
-                .into_iter()
-                .enumerate()
-            {
-                let mut line_spans = Vec::new();
-                if index == 0 {
-                    line_spans.push(Span::styled(
-                        "Intent ",
-                        Style::default().fg(todo_label_color()),
-                    ));
-                    line_spans.push(Span::styled(
-                        state.as_str().to_string(),
-                        Style::default().fg(state_color),
-                    ));
-                    line_spans.push(Span::styled(
-                        ": ".to_string(),
-                        Style::default().fg(todo_label_color()),
-                    ));
-                } else {
-                    line_spans.push(Span::styled(" ".repeat(prefix_width), Style::default()));
-                }
-                line_spans.push(Span::styled(chunk, Style::default().fg(todo_meta_color())));
-                lines.push(todo_card_line(line_spans, base_indent, inner_width));
-            }
-        } else {
-            let mut spans = vec![
-                Span::styled("Intent ", Style::default().fg(todo_label_color())),
-                Span::styled(state.as_str().to_string(), Style::default().fg(state_color)),
-                Span::styled(": ", Style::default().fg(todo_label_color())),
-            ];
-            if let Some(intention) = intention {
-                spans.push(Span::styled(
-                    intention.to_string(),
-                    Style::default().fg(todo_meta_color()),
-                ));
-            }
-            lines.push(todo_card_line(spans, base_indent, inner_width));
-        }
-    } else if let Some(intention) = intention {
-        push_todo_detail(
-            lines,
-            "Intent",
-            intention,
-            base_indent,
-            inner_width,
-            compact_details,
-        );
-    }
-}
-
-fn push_todo_detail(
-    lines: &mut Vec<Line<'static>>,
-    label: &str,
-    value: &str,
-    base_indent: &str,
-    inner_width: usize,
-    compact: bool,
-) {
-    if !compact {
-        push_todo_wrapped_detail(lines, label, value, base_indent, inner_width);
-        return;
-    }
-
-    let prefix = format!("  {} · ", label);
-    lines.push(todo_card_line(
-        vec![
-            Span::styled(prefix, Style::default().fg(todo_label_color())),
-            Span::styled(value.to_string(), Style::default().fg(todo_meta_color())),
-        ],
-        base_indent,
-        inner_width,
-    ));
-}
-
-/// Wrap one labeled detail line to the card width.
-fn push_todo_wrapped_detail(
-    lines: &mut Vec<Line<'static>>,
-    label: &str,
-    value: &str,
-    base_indent: &str,
-    inner_width: usize,
-) {
-    let prefix = format!("  {} · ", label);
-    let prefix_width = prefix.width();
-    let available = inner_width.saturating_sub(prefix_width).max(1);
-    for (index, chunk) in wrap_todo_detail(value, available).into_iter().enumerate() {
-        lines.push(todo_card_line(
-            vec![
-                Span::styled(
-                    if index == 0 {
-                        prefix.clone()
-                    } else {
-                        " ".repeat(prefix_width)
-                    },
-                    Style::default().fg(todo_label_color()),
-                ),
-                Span::styled(chunk, Style::default().fg(todo_meta_color())),
-            ],
-            base_indent,
-            inner_width,
-        ));
-    }
-}
-
-fn push_todo_goal_details(
-    lines: &mut Vec<Line<'static>>,
-    goal: Option<&crate::todo::TodoGoal>,
-    base_indent: &str,
-    inner_width: usize,
-    _compact_details: bool,
-) {
-    let Some(goal) = goal else {
-        return;
-    };
-    let scores = todo_goal_score_spans(goal);
-    if !scores.is_empty() {
-        let score_width = Line::from(scores.clone()).width();
-        let score_count = usize::from(!crate::todo::feedback_loop_passes(
-            goal.closed_feedback_loop,
-        )) + usize::from(!crate::todo::feedback_loop_relevance_passes(goal))
-            + usize::from(!crate::todo::feedback_loop_coverage_passes(goal))
-            + usize::from(!crate::todo::feedback_loop_traceability_passes(goal))
-            + usize::from(goal.delivery_state.is_some());
-        if score_width > inner_width.saturating_sub(2) && score_count > 1 {
-            let mut states: Vec<(&str, String)> = Vec::new();
-            if !crate::todo::feedback_loop_passes(goal.closed_feedback_loop) {
-                states.push((
-                    "Closed feedback loop",
-                    goal.closed_feedback_loop
-                        .map(|state| state.as_str())
-                        .unwrap_or("missing")
-                        .to_string(),
-                ));
-            }
-            if !crate::todo::feedback_loop_relevance_passes(goal) {
-                states.push((
-                    "Relevance",
-                    goal.feedback_loop_relevance
-                        .map(|state| state.as_str())
-                        .unwrap_or("missing")
-                        .to_string(),
-                ));
-            }
-            if !crate::todo::feedback_loop_coverage_passes(goal) {
-                states.push((
-                    "Coverage",
-                    goal.feedback_loop_coverage
-                        .map(|state| state.as_str())
-                        .unwrap_or("missing")
-                        .to_string(),
-                ));
-            }
-            if !crate::todo::feedback_loop_traceability_passes(goal) {
-                states.push((
-                    "Traceability",
-                    goal.feedback_loop_traceability
-                        .map(|state| state.as_str())
-                        .unwrap_or("missing")
-                        .to_string(),
-                ));
-            }
-            if let Some(state) = goal.delivery_state {
-                states.push(("Delivery", state.as_str().to_string()));
-            }
-            for (label, state) in states {
-                let mut spans = vec![Span::raw("  ")];
-                spans.push(Span::styled(
-                    format!("{} ", label),
-                    Style::default().fg(todo_label_color()),
-                ));
-                let color = if label == "Delivery" {
-                    match crate::todo::DeliveryState::parse(&state) {
-                        Some(value) if value >= crate::todo::DeliveryState::WorkflowValidated => {
-                            todo_score_color()
-                        }
-                        Some(crate::todo::DeliveryState::Integrated) => todo_warning_color(),
-                        _ => todo_failure_color(),
-                    }
-                } else if matches!(
-                    state.as_str(),
-                    "missing" | "absent" | "weak" | "indirect" | "narrow" | "unmapped"
-                ) {
-                    todo_failure_color()
-                } else {
-                    todo_warning_color()
-                };
-                spans.push(Span::styled(state, Style::default().fg(color)));
-                lines.push(todo_card_line(spans, base_indent, inner_width));
-            }
-        } else {
-            let mut spans = vec![Span::raw("  ")];
-            spans.extend(scores);
-            lines.push(todo_card_line(spans, base_indent, inner_width));
-        }
-    }
-}
-
-/// Concise refinement card for assessment-only todo writes: the plan-level
-/// intent change first, then any per-goal quality updates.
-fn render_todo_assessment_updates(
-    plan_update: Option<&crate::todo::TodoPlanChange>,
-    goal_updates: &[crate::todo::TodoGoalChange],
-    width: u16,
-) -> Vec<Line<'static>> {
-    let mut lines = render_todo_plan_update(plan_update, width);
-    lines.extend(render_todo_goal_updates(goal_updates, width));
-    lines
-}
-
-fn render_todo_plan_update(
-    plan_update: Option<&crate::todo::TodoPlanChange>,
-    width: u16,
-) -> Vec<Line<'static>> {
-    let Some(update) = plan_update else {
-        return Vec::new();
-    };
-    let intent_is_unclear = !crate::todo::intent_understanding_passes(
-        update
-            .after
-            .as_ref()
-            .and_then(|plan| plan.understands_user_intent),
-    );
-    if !(update
-        .fields
-        .contains(&crate::todo::TodoPlanField::UnderstandsUserIntent)
-        || (intent_is_unclear
-            && update
-                .fields
-                .contains(&crate::todo::TodoPlanField::UserIntention)))
-    {
-        return Vec::new();
-    }
-    let centered = markdown::center_code_blocks();
-    let card_width = if centered {
-        (width.saturating_sub(4) as usize).min(120)
-    } else {
-        (width.saturating_sub(2) as usize).min(100)
-    }
-    .max(1);
-    let base_indent = if centered { "" } else { "  " };
-    let inner_width = card_width.saturating_sub(base_indent.width()).max(1);
-    let mut lines = vec![todo_card_line(
-        vec![
-            Span::styled("Plan", Style::default().fg(todo_group_color()).bold()),
-            Span::styled("  updated", Style::default().fg(todo_meta_color())),
-        ],
-        base_indent,
-        inner_width,
-    )];
-
-    for field in &update.fields {
-        match field {
-            crate::todo::TodoPlanField::UnderstandsUserIntent => push_todo_score_update(
-                &mut lines,
-                "Understands user intent",
-                update
-                    .before
-                    .as_ref()
-                    .and_then(|plan| plan.understands_user_intent)
-                    .map(|state| state.as_str().to_string()),
-                update
-                    .after
-                    .as_ref()
-                    .and_then(|plan| plan.understands_user_intent)
-                    .map(|state| state.as_str().to_string()),
-                base_indent,
-                inner_width,
-            ),
-            crate::todo::TodoPlanField::UserIntention if intent_is_unclear => {
-                push_todo_text_update(
-                    &mut lines,
-                    "User intention",
-                    update
-                        .after
-                        .as_ref()
-                        .and_then(|plan| plan.user_intention.as_deref()),
-                    base_indent,
-                    inner_width,
-                )
-            }
-            crate::todo::TodoPlanField::UserIntention => {}
-        }
-    }
-
-    if centered {
-        left_pad_lines_for_centered_mode(&mut lines, width);
-    }
-    lines
-}
-
-fn render_todo_goal_updates(
-    updates: &[crate::todo::TodoGoalChange],
-    width: u16,
-) -> Vec<Line<'static>> {
-    let centered = markdown::center_code_blocks();
-    let card_width = if centered {
-        (width.saturating_sub(4) as usize).min(120)
-    } else {
-        (width.saturating_sub(2) as usize).min(100)
-    }
-    .max(1);
-    let base_indent = if centered { "" } else { "  " };
-    let inner_width = card_width.saturating_sub(base_indent.width()).max(1);
-    let mut lines = Vec::new();
-
-    for update in updates {
-        // Narrative assessment fields remain available in the dedicated todos
-        // view. Inline tool cards only show the compact state transitions so a
-        // long feedback loop or stopping rationale cannot dominate the chat.
-        let visible_fields = update.fields.iter().filter(|field| {
-            !matches!(
-                field,
-                crate::todo::TodoGoalField::FeedbackLoop
-                    | crate::todo::TodoGoalField::StoppingEvidence
-            )
-        });
-        if visible_fields.clone().next().is_none() {
-            continue;
-        }
-        let goal = update.after.as_ref().or(update.before.as_ref());
-        let label = goal
-            .and_then(|goal| goal.group.as_deref())
-            .map(str::trim)
-            .filter(|group| !group.is_empty())
-            .unwrap_or("Goal");
-        lines.push(todo_card_line(
-            vec![
-                Span::styled(
-                    label.to_string(),
-                    Style::default().fg(todo_group_color()).bold(),
-                ),
-                Span::styled("  updated", Style::default().fg(todo_meta_color())),
-            ],
-            base_indent,
-            inner_width,
-        ));
-
-        for field in visible_fields {
-            match field {
-                crate::todo::TodoGoalField::ClosedFeedbackLoop => push_todo_score_update(
-                    &mut lines,
-                    "Closed feedback loop",
-                    update
-                        .before
-                        .as_ref()
-                        .and_then(|goal| goal.closed_feedback_loop)
-                        .map(|state| state.as_str().to_string()),
-                    update
-                        .after
-                        .as_ref()
-                        .and_then(|goal| goal.closed_feedback_loop)
-                        .map(|state| state.as_str().to_string()),
-                    base_indent,
-                    inner_width,
-                ),
-                crate::todo::TodoGoalField::FeedbackLoopRelevance => push_todo_score_update(
-                    &mut lines,
-                    "Feedback-loop relevance",
-                    update
-                        .before
-                        .as_ref()
-                        .and_then(|goal| goal.feedback_loop_relevance)
-                        .map(|state| state.as_str().to_string()),
-                    update
-                        .after
-                        .as_ref()
-                        .and_then(|goal| goal.feedback_loop_relevance)
-                        .map(|state| state.as_str().to_string()),
-                    base_indent,
-                    inner_width,
-                ),
-                crate::todo::TodoGoalField::FeedbackLoopCoverage => push_todo_score_update(
-                    &mut lines,
-                    "Feedback-loop coverage",
-                    update
-                        .before
-                        .as_ref()
-                        .and_then(|goal| goal.feedback_loop_coverage)
-                        .map(|state| state.as_str().to_string()),
-                    update
-                        .after
-                        .as_ref()
-                        .and_then(|goal| goal.feedback_loop_coverage)
-                        .map(|state| state.as_str().to_string()),
-                    base_indent,
-                    inner_width,
-                ),
-                crate::todo::TodoGoalField::FeedbackLoopTraceability => push_todo_score_update(
-                    &mut lines,
-                    "Feedback-loop traceability",
-                    update
-                        .before
-                        .as_ref()
-                        .and_then(|goal| goal.feedback_loop_traceability)
-                        .map(|state| state.as_str().to_string()),
-                    update
-                        .after
-                        .as_ref()
-                        .and_then(|goal| goal.feedback_loop_traceability)
-                        .map(|state| state.as_str().to_string()),
-                    base_indent,
-                    inner_width,
-                ),
-                crate::todo::TodoGoalField::DeliveryState => push_todo_score_update(
-                    &mut lines,
-                    "Delivery",
-                    update
-                        .before
-                        .as_ref()
-                        .and_then(|goal| goal.delivery_state)
-                        .map(|state| state.as_str().to_string()),
-                    update
-                        .after
-                        .as_ref()
-                        .and_then(|goal| goal.delivery_state)
-                        .map(|state| state.as_str().to_string()),
-                    base_indent,
-                    inner_width,
-                ),
-                crate::todo::TodoGoalField::Autonomy => push_todo_score_update(
-                    &mut lines,
-                    "Autonomy",
-                    update
-                        .before
-                        .as_ref()
-                        .and_then(|goal| goal.autonomy)
-                        .map(|state| state.as_str().to_string()),
-                    update
-                        .after
-                        .as_ref()
-                        .and_then(|goal| goal.autonomy)
-                        .map(|state| state.as_str().to_string()),
-                    base_indent,
-                    inner_width,
-                ),
-                crate::todo::TodoGoalField::IterationMaturity => push_todo_score_update(
-                    &mut lines,
-                    "Iteration",
-                    update
-                        .before
-                        .as_ref()
-                        .and_then(|goal| goal.iteration_maturity)
-                        .map(|state| state.as_str().to_string()),
-                    update
-                        .after
-                        .as_ref()
-                        .and_then(|goal| goal.iteration_maturity)
-                        .map(|state| state.as_str().to_string()),
-                    base_indent,
-                    inner_width,
-                ),
-                crate::todo::TodoGoalField::FeedbackLoop
-                | crate::todo::TodoGoalField::StoppingEvidence => unreachable!(),
-            }
-        }
-    }
-
-    if centered {
-        left_pad_lines_for_centered_mode(&mut lines, width);
-    }
-    lines
-}
-
-fn push_todo_score_update(
-    lines: &mut Vec<Line<'static>>,
-    label: &str,
-    before: Option<String>,
-    after: Option<String>,
-    base_indent: &str,
-    inner_width: usize,
-) {
-    let mut spans = vec![
-        Span::raw("  "),
-        Span::styled(
-            format!("{} ", label),
-            Style::default().fg(todo_label_color()),
-        ),
-    ];
-    match (before, after) {
-        (Some(before), Some(after)) => {
-            spans.push(Span::styled(before, Style::default().fg(todo_meta_color())));
-            spans.push(Span::styled(" → ", Style::default().fg(todo_label_color())));
-            spans.push(Span::styled(after, Style::default().fg(todo_score_color())));
-        }
-        (None, Some(after)) => {
-            spans.push(Span::styled(after, Style::default().fg(todo_score_color())))
-        }
-        (_, None) => spans.push(Span::styled(
-            "cleared",
-            Style::default().fg(todo_meta_color()),
-        )),
-    }
-    lines.push(todo_card_line(spans, base_indent, inner_width));
-}
-
-fn push_todo_text_update(
-    lines: &mut Vec<Line<'static>>,
-    label: &str,
-    after: Option<&str>,
-    base_indent: &str,
-    inner_width: usize,
-) {
-    let value = after.map(str::trim).filter(|value| !value.is_empty());
-    let prefix = format!("  {} · ", label);
-    let prefix_width = prefix.width();
-    let available = inner_width.saturating_sub(prefix_width).max(1);
-    let chunks = value
-        .map(|value| wrap_todo_detail(value, available))
-        .filter(|chunks| !chunks.is_empty())
-        .unwrap_or_else(|| vec!["cleared".to_string()]);
-    for (index, chunk) in chunks.into_iter().enumerate() {
-        lines.push(todo_card_line(
-            vec![
-                Span::styled(
-                    if index == 0 {
-                        prefix.clone()
-                    } else {
-                        " ".repeat(prefix_width)
-                    },
-                    Style::default().fg(todo_label_color()),
-                ),
-                Span::styled(chunk, Style::default().fg(todo_meta_color())),
-            ],
-            base_indent,
-            inner_width,
-        ));
-    }
-}
-
-fn todo_card_confidence_label(todo: &crate::todo::TodoItem) -> Option<String> {
-    if todo.status == "completed"
-        && let (Some(planning), Some(completed)) = (todo.confidence, todo.completion_confidence)
-        && planning != completed
-    {
-        return Some(format!("{}→{}", planning.as_str(), completed.as_str()));
-    }
-    let state = if todo.status == "completed" {
-        todo.completion_confidence.or(todo.confidence)
-    } else {
-        todo.confidence
-    };
-    state.map(|state| state.as_str().to_string())
-}
-
-fn render_todo_card_item_line(
-    todo: &crate::todo::TodoItem,
-    base_indent: &str,
-    inner_width: usize,
-) -> Line<'static> {
-    let blocked = !todo.blocked_by.is_empty() && todo.status != "completed";
-    let (glyph, glyph_color) = if blocked {
-        ("⊳", rgb(225, 165, 90))
-    } else {
-        match todo.status.as_str() {
-            "completed" => ("✓", rgb(105, 190, 125)),
-            "in_progress" => ("●", asap_color()),
-            "cancelled" => ("✗", rgb(190, 105, 115)),
-            _ => ("○", rgb(135, 145, 160)),
-        }
-    };
-    let text_color = match todo.status.as_str() {
-        "completed" => rgb(135, 150, 145),
-        "cancelled" => rgb(145, 130, 135),
-        "in_progress" => rgb(225, 232, 240),
-        _ => rgb(195, 202, 212),
-    };
-    let mut spans = vec![
-        Span::raw("  "),
-        Span::styled(format!("{} ", glyph), Style::default().fg(glyph_color)),
-        Span::styled(todo.content.clone(), Style::default().fg(text_color)),
-    ];
-    if let Some(label) = todo_card_confidence_label(todo) {
-        spans.push(Span::styled(
-            format!(" · {}", label),
-            Style::default().fg(todo_confidence_color()),
-        ));
-    }
-    todo_card_line(spans, base_indent, inner_width)
-}
-
 fn compact_run_id(run_id: &str) -> String {
     if run_id.width() <= 22 {
         run_id.to_string()
diff --git a/crates/jcode-tui/src/tui/ui_messages_todo.rs b/crates/jcode-tui/src/tui/ui_messages_todo.rs
new file mode 100644
index 0000000000..a3824b62b3
--- /dev/null
+++ b/crates/jcode-tui/src/tui/ui_messages_todo.rs
@@ -0,0 +1,867 @@
+//! Todo-card rendering for transcript tool messages.
+//!
+//! Split out of `ui_messages.rs` to keep that file within the code-size
+//! budget; all helpers here render todo/plan/goal card rows.
+
+use super::*;
+
+pub(super) fn todo_card_line(
+    spans: Vec<Span<'static>>,
+    base_indent: &str,
+    inner_width: usize,
+) -> Line<'static> {
+    let mut prefixed = vec![Span::raw(base_indent.to_string())];
+    prefixed.extend(spans);
+    super::truncate_line_with_ellipsis_to_width(
+        &Line::from(prefixed),
+        inner_width.saturating_add(base_indent.width()),
+    )
+}
+
+pub(super) fn todo_card_goal_for_group<'a>(
+    goals: &'a [crate::todo::TodoGoal],
+    group: Option<&str>,
+) -> Option<&'a crate::todo::TodoGoal> {
+    let key = group.map(str::trim).filter(|value| !value.is_empty());
+    goals.iter().find(|goal| {
+        goal.group
+            .as_deref()
+            .map(str::trim)
+            .filter(|value| !value.is_empty())
+            == key
+    })
+}
+
+fn todo_goal_score_spans(goal: &crate::todo::TodoGoal) -> Vec<Span<'static>> {
+    let mut spans = Vec::new();
+    let mut states: Vec<(&str, String, Color)> = Vec::new();
+    if !crate::todo::feedback_loop_passes(goal.closed_feedback_loop) {
+        let (state, color) = goal.closed_feedback_loop.map_or_else(
+            || ("missing".to_string(), todo_failure_color()),
+            |state| {
+                let color = if state <= crate::todo::FeedbackLoopState::Weak {
+                    todo_failure_color()
+                } else {
+                    todo_warning_color()
+                };
+                (state.as_str().to_string(), color)
+            },
+        );
+        states.push(("Closed feedback loop", state, color));
+    }
+    if !crate::todo::feedback_loop_relevance_passes(goal) {
+        let (state, color) = goal.feedback_loop_relevance.map_or_else(
+            || ("missing".to_string(), todo_failure_color()),
+            |state| {
+                let color = if state == crate::todo::FeedbackLoopRelevance::Indirect {
+                    todo_failure_color()
+                } else {
+                    todo_warning_color()
+                };
+                (state.as_str().to_string(), color)
+            },
+        );
+        states.push(("Relevance", state, color));
+    }
+    if !crate::todo::feedback_loop_coverage_passes(goal) {
+        let (state, color) = goal.feedback_loop_coverage.map_or_else(
+            || ("missing".to_string(), todo_failure_color()),
+            |state| {
+                let color = if state == crate::todo::FeedbackLoopCoverage::Narrow {
+                    todo_failure_color()
+                } else {
+                    todo_warning_color()
+                };
+                (state.as_str().to_string(), color)
+            },
+        );
+        states.push(("Coverage", state, color));
+    }
+    if !crate::todo::feedback_loop_traceability_passes(goal) {
+        let (state, color) = goal.feedback_loop_traceability.map_or_else(
+            || ("missing".to_string(), todo_failure_color()),
+            |state| {
+                let color = if state == crate::todo::FeedbackLoopTraceability::Unmapped {
+                    todo_failure_color()
+                } else {
+                    todo_warning_color()
+                };
+                (state.as_str().to_string(), color)
+            },
+        );
+        states.push(("Traceability", state, color));
+    }
+
+    if states.is_empty() {
+        spans.push(Span::styled(
+            "✓ All quality gates passing",
+            Style::default().fg(todo_score_color()),
+        ));
+    }
+
+    for (index, (label, state, color)) in states.into_iter().enumerate() {
+        if index > 0 {
+            spans.push(Span::styled(" · ", Style::default().fg(dim_color())));
+        }
+        spans.push(Span::styled(
+            format!("{} ", label),
+            Style::default().fg(todo_label_color()),
+        ));
+        spans.push(Span::styled(state, Style::default().fg(color)));
+    }
+
+    // Delivery is progress toward the outcome, not a quality gate. Keep it
+    // visible and visually separate from failures so it cannot read as one.
+    if let Some(state) = goal.delivery_state {
+        if !spans.is_empty() {
+            spans.push(Span::styled(" · ", Style::default().fg(dim_color())));
+        }
+        spans.push(Span::styled(
+            "Delivery ",
+            Style::default().fg(todo_label_color()),
+        ));
+        let color = if state >= crate::todo::DeliveryState::WorkflowValidated {
+            todo_score_color()
+        } else if state == crate::todo::DeliveryState::Integrated {
+            todo_warning_color()
+        } else {
+            todo_failure_color()
+        };
+        spans.push(Span::styled(
+            state.as_str().to_string(),
+            Style::default().fg(color),
+        ));
+    }
+    spans
+}
+
+fn push_todo_status_pips<'a>(
+    spans: &mut Vec<Span<'static>>,
+    todos: impl IntoIterator<Item = &'a crate::todo::TodoItem>,
+    max_pips: usize,
+) {
+    let (completed, in_progress, total) =
+        todos
+            .into_iter()
+            .fold((0usize, 0usize, 0usize), |counts, todo| {
+                (
+                    counts.0 + usize::from(todo.status == "completed"),
+                    counts.1 + usize::from(todo.status == "in_progress"),
+                    counts.2 + 1,
+                )
+            });
+    if total == 0 || max_pips == 0 {
+        return;
+    }
+
+    let (done_pips, active_pips, open_pips) = if total <= max_pips.max(12) {
+        (
+            completed,
+            in_progress,
+            total.saturating_sub(completed + in_progress),
+        )
+    } else {
+        let scale =
+            |count: usize| ((count as f64 / total as f64) * max_pips as f64).round() as usize;
+        let mut done = scale(completed);
+        let mut active = scale(in_progress);
+        if completed > 0 && done == 0 {
+            done = 1;
+        }
+        if in_progress > 0 && active == 0 {
+            active = 1;
+        }
+        done = done.min(max_pips);
+        active = active.min(max_pips.saturating_sub(done));
+        (done, active, max_pips.saturating_sub(done + active))
+    };
+
+    for _ in 0..done_pips {
+        spans.push(Span::styled("●", Style::default().fg(rgb(100, 180, 100))));
+    }
+    for _ in 0..active_pips {
+        spans.push(Span::styled("●", Style::default().fg(asap_color())));
+    }
+    for _ in 0..open_pips {
+        spans.push(Span::styled("○", Style::default().fg(rgb(90, 90, 105))));
+    }
+}
+
+pub(super) fn render_todo_status_header<'a>(
+    todos: impl IntoIterator<Item = &'a crate::todo::TodoItem>,
+    base_indent: &str,
+    inner_width: usize,
+) -> Line<'static> {
+    let mut spans = Vec::new();
+    push_todo_status_pips(&mut spans, todos, inner_width);
+    todo_card_line(spans, base_indent, inner_width)
+}
+
+pub(super) fn render_todo_goal_header(
+    label: &str,
+    todos: &[&crate::todo::TodoItem],
+    base_indent: &str,
+    inner_width: usize,
+) -> Line<'static> {
+    let label_width = label.width();
+    let mut spans = vec![Span::styled(
+        label.to_string(),
+        Style::default().fg(todo_group_color()).bold(),
+    )];
+    spans.push(Span::raw("  "));
+    push_todo_status_pips(
+        &mut spans,
+        todos.iter().copied(),
+        inner_width.saturating_sub(label_width + 2),
+    );
+    todo_card_line(spans, base_indent, inner_width)
+}
+
+fn wrap_todo_detail(value: &str, width: usize) -> Vec<String> {
+    let width = width.max(1);
+    let mut chunks = Vec::new();
+    let mut current = String::new();
+
+    for word in value.split_whitespace() {
+        let word_width = word.width();
+        if !current.is_empty() && current.width() + 1 + word_width <= width {
+            current.push(' ');
+            current.push_str(word);
+            continue;
+        }
+        if current.is_empty() && word_width <= width {
+            current.push_str(word);
+            continue;
+        }
+        if !current.is_empty() {
+            chunks.push(std::mem::take(&mut current));
+        }
+        if word_width <= width {
+            current.push_str(word);
+            continue;
+        }
+        let mut word_chunks = split_by_display_width(word, width).into_iter().peekable();
+        while let Some(chunk) = word_chunks.next() {
+            if word_chunks.peek().is_some() {
+                chunks.push(chunk);
+            } else {
+                current = chunk;
+            }
+        }
+    }
+    if !current.is_empty() {
+        chunks.push(current);
+    }
+    chunks
+}
+
+/// Plan-level assessment lines shown once above the todo groups.
+pub(super) fn push_todo_plan_details(
+    lines: &mut Vec<Line<'static>>,
+    plan: &crate::todo::TodoPlan,
+    base_indent: &str,
+    inner_width: usize,
+    compact_details: bool,
+) {
+    let intention = plan
+        .user_intention
+        .as_deref()
+        .map(str::trim)
+        .filter(|value| !value.is_empty());
+    if let Some(state) = plan.understands_user_intent {
+        let state_color = match state {
+            crate::todo::IntentUnderstanding::Uncertain => todo_failure_color(),
+            crate::todo::IntentUnderstanding::Partial => todo_warning_color(),
+            crate::todo::IntentUnderstanding::Clear
+            | crate::todo::IntentUnderstanding::Complete => todo_score_color(),
+        };
+        let intention_text = intention.unwrap_or_default();
+        let intent_clear = matches!(
+            state,
+            crate::todo::IntentUnderstanding::Clear | crate::todo::IntentUnderstanding::Complete
+        );
+        if !compact_details && intent_clear && !intention_text.is_empty() {
+            // A clear plan intention is worth reading in full, so wrap it
+            // across card rows instead of clipping it to an ellipsis. Partial or
+            // uncertain states stay on one ellipsized line: the state itself is
+            // the signal, and the plan text is still subject to revision.
+            // Keep the state in its own span so semantic colors stay testable.
+            push_todo_wrapped_spans(
+                lines,
+                &[
+                    Span::styled("Intent ", Style::default().fg(todo_label_color())),
+                    Span::styled(state.as_str().to_string(), Style::default().fg(state_color)),
+                    Span::styled(": ", Style::default().fg(todo_label_color())),
+                ],
+                intention_text,
+                base_indent,
+                inner_width,
+            );
+        } else {
+            let mut spans = vec![
+                Span::styled("Intent ", Style::default().fg(todo_label_color())),
+                Span::styled(state.as_str().to_string(), Style::default().fg(state_color)),
+                Span::styled(": ", Style::default().fg(todo_label_color())),
+            ];
+            if let Some(intention) = intention {
+                spans.push(Span::styled(
+                    intention.to_string(),
+                    Style::default().fg(todo_meta_color()),
+                ));
+            }
+            lines.push(todo_card_line(spans, base_indent, inner_width));
+        }
+    } else if let Some(intention) = intention {
+        push_todo_detail(
+            lines,
+            "Intent",
+            intention,
+            base_indent,
+            inner_width,
+            compact_details,
+        );
+    }
+}
+
+fn push_todo_detail(
+    lines: &mut Vec<Line<'static>>,
+    label: &str,
+    value: &str,
+    base_indent: &str,
+    inner_width: usize,
+    compact: bool,
+) {
+    if !compact {
+        push_todo_wrapped_detail(lines, label, value, base_indent, inner_width);
+        return;
+    }
+
+    let prefix = format!("  {} · ", label);
+    lines.push(todo_card_line(
+        vec![
+            Span::styled(prefix, Style::default().fg(todo_label_color())),
+            Span::styled(value.to_string(), Style::default().fg(todo_meta_color())),
+        ],
+        base_indent,
+        inner_width,
+    ));
+}
+
+/// Wrap one labeled detail line to the card width.
+fn push_todo_wrapped_detail(
+    lines: &mut Vec<Line<'static>>,
+    label: &str,
+    value: &str,
+    base_indent: &str,
+    inner_width: usize,
+) {
+    let prefix = format!("  {} · ", label);
+    push_todo_wrapped_spans(
+        lines,
+        &[Span::styled(
+            prefix,
+            Style::default().fg(todo_label_color()),
+        )],
+        value,
+        base_indent,
+        inner_width,
+    );
+}
+
+/// Wrap `value` across card rows after a styled prefix; later rows are padded
+/// so the wrapped text lines up under the first.
+fn push_todo_wrapped_spans(
+    lines: &mut Vec<Line<'static>>,
+    prefix_spans: &[Span<'static>],
+    value: &str,
+    base_indent: &str,
+    inner_width: usize,
+) {
+    let prefix_width: usize = prefix_spans.iter().map(|s| s.width()).sum();
+    let available = inner_width.saturating_sub(prefix_width).max(1);
+    for (index, chunk) in wrap_todo_detail(value, available).into_iter().enumerate() {
+        let mut spans = if index == 0 {
+            prefix_spans.to_vec()
+        } else {
+            vec![Span::raw(" ".repeat(prefix_width))]
+        };
+        spans.push(Span::styled(chunk, Style::default().fg(todo_meta_color())));
+        lines.push(todo_card_line(spans, base_indent, inner_width));
+    }
+}
+
+pub(super) fn push_todo_goal_details(
+    lines: &mut Vec<Line<'static>>,
+    goal: Option<&crate::todo::TodoGoal>,
+    base_indent: &str,
+    inner_width: usize,
+    _compact_details: bool,
+) {
+    let Some(goal) = goal else {
+        return;
+    };
+    let scores = todo_goal_score_spans(goal);
+    if !scores.is_empty() {
+        let score_width = Line::from(scores.clone()).width();
+        let score_count = usize::from(!crate::todo::feedback_loop_passes(
+            goal.closed_feedback_loop,
+        )) + usize::from(!crate::todo::feedback_loop_relevance_passes(goal))
+            + usize::from(!crate::todo::feedback_loop_coverage_passes(goal))
+            + usize::from(!crate::todo::feedback_loop_traceability_passes(goal))
+            + usize::from(goal.delivery_state.is_some());
+        if score_width > inner_width.saturating_sub(2) && score_count > 1 {
+            let mut states: Vec<(&str, String)> = Vec::new();
+            if !crate::todo::feedback_loop_passes(goal.closed_feedback_loop) {
+                states.push((
+                    "Closed feedback loop",
+                    goal.closed_feedback_loop
+                        .map(|state| state.as_str())
+                        .unwrap_or("missing")
+                        .to_string(),
+                ));
+            }
+            if !crate::todo::feedback_loop_relevance_passes(goal) {
+                states.push((
+                    "Relevance",
+                    goal.feedback_loop_relevance
+                        .map(|state| state.as_str())
+                        .unwrap_or("missing")
+                        .to_string(),
+                ));
+            }
+            if !crate::todo::feedback_loop_coverage_passes(goal) {
+                states.push((
+                    "Coverage",
+                    goal.feedback_loop_coverage
+                        .map(|state| state.as_str())
+                        .unwrap_or("missing")
+                        .to_string(),
+                ));
+            }
+            if !crate::todo::feedback_loop_traceability_passes(goal) {
+                states.push((
+                    "Traceability",
+                    goal.feedback_loop_traceability
+                        .map(|state| state.as_str())
+                        .unwrap_or("missing")
+                        .to_string(),
+                ));
+            }
+            if let Some(state) = goal.delivery_state {
+                states.push(("Delivery", state.as_str().to_string()));
+            }
+            for (label, state) in states {
+                let mut spans = vec![Span::raw("  ")];
+                spans.push(Span::styled(
+                    format!("{} ", label),
+                    Style::default().fg(todo_label_color()),
+                ));
+                let color = if label == "Delivery" {
+                    match crate::todo::DeliveryState::parse(&state) {
+                        Some(value) if value >= crate::todo::DeliveryState::WorkflowValidated => {
+                            todo_score_color()
+                        }
+                        Some(crate::todo::DeliveryState::Integrated) => todo_warning_color(),
+                        _ => todo_failure_color(),
+                    }
+                } else if matches!(
+                    state.as_str(),
+                    "missing" | "absent" | "weak" | "indirect" | "narrow" | "unmapped"
+                ) {
+                    todo_failure_color()
+                } else {
+                    todo_warning_color()
+                };
+                spans.push(Span::styled(state, Style::default().fg(color)));
+                lines.push(todo_card_line(spans, base_indent, inner_width));
+            }
+        } else {
+            let mut spans = vec![Span::raw("  ")];
+            spans.extend(scores);
+            lines.push(todo_card_line(spans, base_indent, inner_width));
+        }
+    }
+}
+
+/// Concise refinement card for assessment-only todo writes: the plan-level
+/// intent change first, then any per-goal quality updates.
+pub(super) fn render_todo_assessment_updates(
+    plan_update: Option<&crate::todo::TodoPlanChange>,
+    goal_updates: &[crate::todo::TodoGoalChange],
+    width: u16,
+) -> Vec<Line<'static>> {
+    let mut lines = render_todo_plan_update(plan_update, width);
+    lines.extend(render_todo_goal_updates(goal_updates, width));
+    lines
+}
+
+fn render_todo_plan_update(
+    plan_update: Option<&crate::todo::TodoPlanChange>,
+    width: u16,
+) -> Vec<Line<'static>> {
+    let Some(update) = plan_update else {
+        return Vec::new();
+    };
+    let intent_is_unclear = !crate::todo::intent_understanding_passes(
+        update
+            .after
+            .as_ref()
+            .and_then(|plan| plan.understands_user_intent),
+    );
+    if !(update
+        .fields
+        .contains(&crate::todo::TodoPlanField::UnderstandsUserIntent)
+        || (intent_is_unclear
+            && update
+                .fields
+                .contains(&crate::todo::TodoPlanField::UserIntention)))
+    {
+        return Vec::new();
+    }
+    let centered = markdown::center_code_blocks();
+    let card_width = if centered {
+        (width.saturating_sub(4) as usize).min(120)
+    } else {
+        (width.saturating_sub(2) as usize).min(100)
+    }
+    .max(1);
+    let base_indent = if centered { "" } else { "  " };
+    let inner_width = card_width.saturating_sub(base_indent.width()).max(1);
+    let mut lines = vec![todo_card_line(
+        vec![
+            Span::styled("Plan", Style::default().fg(todo_group_color()).bold()),
+            Span::styled("  updated", Style::default().fg(todo_meta_color())),
+        ],
+        base_indent,
+        inner_width,
+    )];
+
+    for field in &update.fields {
+        match field {
+            crate::todo::TodoPlanField::UnderstandsUserIntent => push_todo_score_update(
+                &mut lines,
+                "Understands user intent",
+                update
+                    .before
+                    .as_ref()
+                    .and_then(|plan| plan.understands_user_intent)
+                    .map(|state| state.as_str().to_string()),
+                update
+                    .after
+                    .as_ref()
+                    .and_then(|plan| plan.understands_user_intent)
+                    .map(|state| state.as_str().to_string()),
+                base_indent,
+                inner_width,
+            ),
+            crate::todo::TodoPlanField::UserIntention if intent_is_unclear => {
+                push_todo_text_update(
+                    &mut lines,
+                    "User intention",
+                    update
+                        .after
+                        .as_ref()
+                        .and_then(|plan| plan.user_intention.as_deref()),
+                    base_indent,
+                    inner_width,
+                )
+            }
+            crate::todo::TodoPlanField::UserIntention => {}
+        }
+    }
+
+    if centered {
+        left_pad_lines_for_centered_mode(&mut lines, width);
+    }
+    lines
+}
+
+pub(crate) fn render_todo_goal_updates(
+    updates: &[crate::todo::TodoGoalChange],
+    width: u16,
+) -> Vec<Line<'static>> {
+    let centered = markdown::center_code_blocks();
+    let card_width = if centered {
+        (width.saturating_sub(4) as usize).min(120)
+    } else {
+        (width.saturating_sub(2) as usize).min(100)
+    }
+    .max(1);
+    let base_indent = if centered { "" } else { "  " };
+    let inner_width = card_width.saturating_sub(base_indent.width()).max(1);
+    let mut lines = Vec::new();
+
+    for update in updates {
+        // Narrative assessment fields remain available in the dedicated todos
+        // view. Inline tool cards only show the compact state transitions so a
+        // long feedback loop or stopping rationale cannot dominate the chat.
+        let visible_fields = update.fields.iter().filter(|field| {
+            !matches!(
+                field,
+                crate::todo::TodoGoalField::FeedbackLoop
+                    | crate::todo::TodoGoalField::StoppingEvidence
+            )
+        });
+        if visible_fields.clone().next().is_none() {
+            continue;
+        }
+        let goal = update.after.as_ref().or(update.before.as_ref());
+        let label = goal
+            .and_then(|goal| goal.group.as_deref())
+            .map(str::trim)
+            .filter(|group| !group.is_empty())
+            .unwrap_or("Goal");
+        lines.push(todo_card_line(
+            vec![
+                Span::styled(
+                    label.to_string(),
+                    Style::default().fg(todo_group_color()).bold(),
+                ),
+                Span::styled("  updated", Style::default().fg(todo_meta_color())),
+            ],
+            base_indent,
+            inner_width,
+        ));
+
+        for field in visible_fields {
+            match field {
+                crate::todo::TodoGoalField::ClosedFeedbackLoop => push_todo_score_update(
+                    &mut lines,
+                    "Closed feedback loop",
+                    update
+                        .before
+                        .as_ref()
+                        .and_then(|goal| goal.closed_feedback_loop)
+                        .map(|state| state.as_str().to_string()),
+                    update
+                        .after
+                        .as_ref()
+                        .and_then(|goal| goal.closed_feedback_loop)
+                        .map(|state| state.as_str().to_string()),
+                    base_indent,
+                    inner_width,
+                ),
+                crate::todo::TodoGoalField::FeedbackLoopRelevance => push_todo_score_update(
+                    &mut lines,
+                    "Feedback-loop relevance",
+                    update
+                        .before
+                        .as_ref()
+                        .and_then(|goal| goal.feedback_loop_relevance)
+                        .map(|state| state.as_str().to_string()),
+                    update
+                        .after
+                        .as_ref()
+                        .and_then(|goal| goal.feedback_loop_relevance)
+                        .map(|state| state.as_str().to_string()),
+                    base_indent,
+                    inner_width,
+                ),
+                crate::todo::TodoGoalField::FeedbackLoopCoverage => push_todo_score_update(
+                    &mut lines,
+                    "Feedback-loop coverage",
+                    update
+                        .before
+                        .as_ref()
+                        .and_then(|goal| goal.feedback_loop_coverage)
+                        .map(|state| state.as_str().to_string()),
+                    update
+                        .after
+                        .as_ref()
+                        .and_then(|goal| goal.feedback_loop_coverage)
+                        .map(|state| state.as_str().to_string()),
+                    base_indent,
+                    inner_width,
+                ),
+                crate::todo::TodoGoalField::FeedbackLoopTraceability => push_todo_score_update(
+                    &mut lines,
+                    "Feedback-loop traceability",
+                    update
+                        .before
+                        .as_ref()
+                        .and_then(|goal| goal.feedback_loop_traceability)
+                        .map(|state| state.as_str().to_string()),
+                    update
+                        .after
+                        .as_ref()
+                        .and_then(|goal| goal.feedback_loop_traceability)
+                        .map(|state| state.as_str().to_string()),
+                    base_indent,
+                    inner_width,
+                ),
+                crate::todo::TodoGoalField::DeliveryState => push_todo_score_update(
+                    &mut lines,
+                    "Delivery",
+                    update
+                        .before
+                        .as_ref()
+                        .and_then(|goal| goal.delivery_state)
+                        .map(|state| state.as_str().to_string()),
+                    update
+                        .after
+                        .as_ref()
+                        .and_then(|goal| goal.delivery_state)
+                        .map(|state| state.as_str().to_string()),
+                    base_indent,
+                    inner_width,
+                ),
+                crate::todo::TodoGoalField::Autonomy => push_todo_score_update(
+                    &mut lines,
+                    "Autonomy",
+                    update
+                        .before
+                        .as_ref()
+                        .and_then(|goal| goal.autonomy)
+                        .map(|state| state.as_str().to_string()),
+                    update
+                        .after
+                        .as_ref()
+                        .and_then(|goal| goal.autonomy)
+                        .map(|state| state.as_str().to_string()),
+                    base_indent,
+                    inner_width,
+                ),
+                crate::todo::TodoGoalField::IterationMaturity => push_todo_score_update(
+                    &mut lines,
+                    "Iteration",
+                    update
+                        .before
+                        .as_ref()
+                        .and_then(|goal| goal.iteration_maturity)
+                        .map(|state| state.as_str().to_string()),
+                    update
+                        .after
+                        .as_ref()
+                        .and_then(|goal| goal.iteration_maturity)
+                        .map(|state| state.as_str().to_string()),
+                    base_indent,
+                    inner_width,
+                ),
+                crate::todo::TodoGoalField::FeedbackLoop
+                | crate::todo::TodoGoalField::StoppingEvidence => unreachable!(),
+            }
+        }
+    }
+
+    if centered {
+        left_pad_lines_for_centered_mode(&mut lines, width);
+    }
+    lines
+}
+
+fn push_todo_score_update(
+    lines: &mut Vec<Line<'static>>,
+    label: &str,
+    before: Option<String>,
+    after: Option<String>,
+    base_indent: &str,
+    inner_width: usize,
+) {
+    let mut spans = vec![
+        Span::raw("  "),
+        Span::styled(
+            format!("{} ", label),
+            Style::default().fg(todo_label_color()),
+        ),
+    ];
+    match (before, after) {
+        (Some(before), Some(after)) => {
+            spans.push(Span::styled(before, Style::default().fg(todo_meta_color())));
+            spans.push(Span::styled(" → ", Style::default().fg(todo_label_color())));
+            spans.push(Span::styled(after, Style::default().fg(todo_score_color())));
+        }
+        (None, Some(after)) => {
+            spans.push(Span::styled(after, Style::default().fg(todo_score_color())))
+        }
+        (_, None) => spans.push(Span::styled(
+            "cleared",
+            Style::default().fg(todo_meta_color()),
+        )),
+    }
+    lines.push(todo_card_line(spans, base_indent, inner_width));
+}
+
+fn push_todo_text_update(
+    lines: &mut Vec<Line<'static>>,
+    label: &str,
+    after: Option<&str>,
+    base_indent: &str,
+    inner_width: usize,
+) {
+    let value = after.map(str::trim).filter(|value| !value.is_empty());
+    let prefix = format!("  {} · ", label);
+    let prefix_width = prefix.width();
+    let available = inner_width.saturating_sub(prefix_width).max(1);
+    let chunks = value
+        .map(|value| wrap_todo_detail(value, available))
+        .filter(|chunks| !chunks.is_empty())
+        .unwrap_or_else(|| vec!["cleared".to_string()]);
+    for (index, chunk) in chunks.into_iter().enumerate() {
+        lines.push(todo_card_line(
+            vec![
+                Span::styled(
+                    if index == 0 {
+                        prefix.clone()
+                    } else {
+                        " ".repeat(prefix_width)
+                    },
+                    Style::default().fg(todo_label_color()),
+                ),
+                Span::styled(chunk, Style::default().fg(todo_meta_color())),
+            ],
+            base_indent,
+            inner_width,
+        ));
+    }
+}
+
+fn todo_card_confidence_label(todo: &crate::todo::TodoItem) -> Option<String> {
+    if todo.status == "completed"
+        && let (Some(planning), Some(completed)) = (todo.confidence, todo.completion_confidence)
+        && planning != completed
+    {
+        return Some(format!("{}→{}", planning.as_str(), completed.as_str()));
+    }
+    let state = if todo.status == "completed" {
+        todo.completion_confidence.or(todo.confidence)
+    } else {
+        todo.confidence
+    };
+    state.map(|state| state.as_str().to_string())
+}
+
+pub(super) fn render_todo_card_item_line(
+    todo: &crate::todo::TodoItem,
+    base_indent: &str,
+    inner_width: usize,
+) -> Line<'static> {
+    let blocked = !todo.blocked_by.is_empty() && todo.status != "completed";
+    let (glyph, glyph_color) = if blocked {
+        ("⊳", rgb(225, 165, 90))
+    } else {
+        match todo.status.as_str() {
+            "completed" => ("✓", rgb(105, 190, 125)),
+            "in_progress" => ("●", asap_color()),
+            "cancelled" => ("✗", rgb(190, 105, 115)),
+            _ => ("○", rgb(135, 145, 160)),
+        }
+    };
+    let text_color = match todo.status.as_str() {
+        "completed" => rgb(135, 150, 145),
+        "cancelled" => rgb(145, 130, 135),
+        "in_progress" => rgb(225, 232, 240),
+        _ => rgb(195, 202, 212),
+    };
+    let mut spans = vec![
+        Span::raw("  "),
+        Span::styled(format!("{} ", glyph), Style::default().fg(glyph_color)),
+        Span::styled(todo.content.clone(), Style::default().fg(text_color)),
+    ];
+    if let Some(label) = todo_card_confidence_label(todo) {
+        spans.push(Span::styled(
+            format!(" · {}", label),
+            Style::default().fg(todo_confidence_color()),
+        ));
+    }
+    todo_card_line(spans, base_indent, inner_width)
+}

From f52fb5b1f8ffaccd21b0ed3987a7e29c0c685538 Mon Sep 17 00:00:00 2001
From: Alejandro Blanco-M <alecuba16@gmail.com>
Date: Sat, 19 Sep 2026 18:40:46 +0200
Subject: [PATCH 17/21] test(tui): keep oversized test files within the ratchet
 budget

Compacting the two tracked oversized test files (scroll_copy_02 and
state_model_poke_02) back to their baseline LOC after the expectation
refresh: the notice match becomes a prefix check, the account upsert
loop becomes a capture closure. No behavior change.
---
 .../src/tui/app/tests/scroll_copy_02/part_01.rs  | 15 ++++++---------
 .../tui/app/tests/state_model_poke_02/part_01.rs | 16 ++++++----------
 2 files changed, 12 insertions(+), 19 deletions(-)

diff --git a/crates/jcode-tui/src/tui/app/tests/scroll_copy_02/part_01.rs b/crates/jcode-tui/src/tui/app/tests/scroll_copy_02/part_01.rs
index 5d7667f653..e6edff1eb5 100644
--- a/crates/jcode-tui/src/tui/app/tests/scroll_copy_02/part_01.rs
+++ b/crates/jcode-tui/src/tui/app/tests/scroll_copy_02/part_01.rs
@@ -1474,13 +1474,10 @@ fn test_changelog_overlay_mouse_drag_release_copies_text() {
         modifiers: KeyModifiers::empty(),
     });
 
-    // A copy was attempted (success/failure depends on clipboard availability
-    // in the test environment, but the selection path must have run).
-    assert!(matches!(
-        app.status_notice().as_deref(),
-        Some("Copied selection")
-            | Some("Copied selection · highlight remains visible")
-            | Some("Failed to copy selection")
-            | Some("Selection is empty")
-    ));
+    // A copy was attempted (clipboard availability varies, but the path must
+    // run). Drag-copy keeps the highlight and appends a suffix to the notice.
+    let notice = app.status_notice().unwrap_or_default();
+    assert!(["Copied selection", "Failed to copy selection", "Selection is empty"]
+        .iter()
+        .any(|base| notice == *base || notice.starts_with(base)));
 }
diff --git a/crates/jcode-tui/src/tui/app/tests/state_model_poke_02/part_01.rs b/crates/jcode-tui/src/tui/app/tests/state_model_poke_02/part_01.rs
index 970ba2382f..a74c0a68c5 100644
--- a/crates/jcode-tui/src/tui/app/tests/state_model_poke_02/part_01.rs
+++ b/crates/jcode-tui/src/tui/app/tests/state_model_poke_02/part_01.rs
@@ -1004,11 +1004,9 @@ fn test_top_level_command_suggestions_include_all_non_hidden_commands() {
 #[test]
 fn test_logout_clear_anthropic_accounts_removes_all_accounts_once() {
     with_temp_jcode_home(|| {
-        // Upsert canonicalizes labels with animal names (claude-otter,
-        // claude-fox, claude-panda), so collect the assigned labels.
-        let mut labels_assigned: Vec<String> = Vec::new();
-        for index in 1..=3 {
-            let label = crate::auth::claude::upsert_account(crate::auth::claude::AnthropicAccount {
+        // Upsert canonicalizes labels with animal names, so capture them.
+        let upsert = |index: i64| {
+            crate::auth::claude::upsert_account(crate::auth::claude::AnthropicAccount {
                 label: format!("requested-{index}"),
                 access: format!("access-{index}"),
                 refresh: format!("refresh-{index}"),
@@ -1017,18 +1015,16 @@ fn test_logout_clear_anthropic_accounts_removes_all_accounts_once() {
                 subscription_type: None,
                 scopes: Vec::new(),
             })
-            .unwrap();
-            labels_assigned.push(label);
-        }
+            .unwrap()
+        };
+        let labels_assigned: Vec<String> = (1..=3).map(upsert).collect();
         crate::auth::claude::set_active_account(&labels_assigned[2]).unwrap();
-
         let labels: Vec<_> = crate::auth::claude::list_accounts()
             .unwrap()
             .into_iter()
             .map(|account| account.label)
             .collect();
         assert_eq!(labels, labels_assigned);
-
         assert_eq!(crate::auth::claude::clear_accounts().unwrap(), 3);
         assert!(crate::auth::claude::list_accounts().unwrap().is_empty());
         assert!(crate::auth::claude::active_account_label().is_none());

From bd87755c18fbb50d69a96f759da3bdf80fecbf8a Mon Sep 17 00:00:00 2001
From: Alejandro Blanco-M <alecuba16@gmail.com>
Date: Sat, 19 Sep 2026 18:53:13 +0200
Subject: [PATCH 18/21] fix(tui): avoid new swallowed-error usage in intent
 wrap

The guardrail budget forbids growing unwrap_or_default counts; use
Option::filter on the intention instead.
---
 crates/jcode-tui/src/tui/ui_messages_todo.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/crates/jcode-tui/src/tui/ui_messages_todo.rs b/crates/jcode-tui/src/tui/ui_messages_todo.rs
index a3824b62b3..374c4c0f1a 100644
--- a/crates/jcode-tui/src/tui/ui_messages_todo.rs
+++ b/crates/jcode-tui/src/tui/ui_messages_todo.rs
@@ -275,12 +275,11 @@ pub(super) fn push_todo_plan_details(
             crate::todo::IntentUnderstanding::Clear
             | crate::todo::IntentUnderstanding::Complete => todo_score_color(),
         };
-        let intention_text = intention.unwrap_or_default();
         let intent_clear = matches!(
             state,
             crate::todo::IntentUnderstanding::Clear | crate::todo::IntentUnderstanding::Complete
         );
-        if !compact_details && intent_clear && !intention_text.is_empty() {
+        if let Some(intention_text) = intention.filter(|_| intent_clear && !compact_details) {
             // A clear plan intention is worth reading in full, so wrap it
             // across card rows instead of clipping it to an ellipsis. Partial or
             // uncertain states stay on one ellipsized line: the state itself is

From 4746bd927162d27b9cbf3d627b1d484369e529e5 Mon Sep 17 00:00:00 2001
From: Alejandro Blanco-M <alecuba16@gmail.com>
Date: Sat, 19 Sep 2026 19:42:16 +0200
Subject: [PATCH 19/21] fix(auth): add OrcaRouter to the provider choice
 mapping

a2622db13 added the OrcaRouter login provider (OpenAI-compatible
gateway) but no ProviderChoice entry, so choice_for_login_provider
returned None for it and the provider matrix test failed: every
compatible login provider must map to a choice. Follows the Novita
pattern (1f9a56a4c): enum variant, as_str, mapping-table pair, and
the OpenAI-compatible init arm.
---
 src/cli/provider_init.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/cli/provider_init.rs b/src/cli/provider_init.rs
index 5823eeb3ab..0fd0a2b7a0 100644
--- a/src/cli/provider_init.rs
+++ b/src/cli/provider_init.rs
@@ -90,6 +90,8 @@ pub enum ProviderChoice {
     Fireworks,
     #[value(alias = "novita-ai", alias = "novita.ai")]
     Novita,
+    #[value(alias = "orca-router")]
+    OrcaRouter,
     #[value(alias = "minimax-ai", alias = "minimaxi")]
     Minimax,
     #[value(alias = "x.ai", alias = "x-ai", alias = "grok")]
@@ -180,6 +182,7 @@ impl ProviderChoice {
             Self::Deepinfra => "deepinfra",
             Self::Fireworks => "fireworks",
             Self::Novita => "novita",
+            Self::OrcaRouter => "orcarouter",
             Self::Minimax => "minimax",
             Self::Xai => "xai",
             Self::GrokBuild => "grok-build",
@@ -339,6 +342,10 @@ const PROVIDER_CHOICE_LOGIN_PROVIDERS: &[(ProviderChoice, LoginProviderDescripto
         ProviderChoice::Novita,
         crate::provider_catalog::NOVITA_LOGIN_PROVIDER,
     ),
+    (
+        ProviderChoice::OrcaRouter,
+        crate::provider_catalog::ORCAROUTER_LOGIN_PROVIDER,
+    ),
     (
         ProviderChoice::Minimax,
         crate::provider_catalog::MINIMAX_LOGIN_PROVIDER,
@@ -1595,6 +1602,7 @@ async fn init_provider_with_options(
         | ProviderChoice::Deepinfra
         | ProviderChoice::Fireworks
         | ProviderChoice::Novita
+        | ProviderChoice::OrcaRouter
         | ProviderChoice::Minimax
         | ProviderChoice::Xai
         | ProviderChoice::NvidiaNim

From 51b2d9374bc07396bbe6444c964d28c01a82661d Mon Sep 17 00:00:00 2001
From: Alejandro Blanco-M <alecuba16@gmail.com>
Date: Sat, 19 Sep 2026 19:50:39 +0200
Subject: [PATCH 20/21] test: refresh provider_init size baseline for
 OrcaRouter mapping

Same convention as 1e41bac3e: an intentional provider addition grows
the tracked file; bump the ratchet baseline 1908 -> 1916 for the
OrcaRouter choice mapping (mirrors the Novita +8 in 1f9a56a4c).
---
 scripts/code_size_budget.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/code_size_budget.json b/scripts/code_size_budget.json
index 0ca5948efe..46dc1135b8 100644
--- a/scripts/code_size_budget.json
+++ b/scripts/code_size_budget.json
@@ -106,7 +106,7 @@
     "src/cli/commands.rs": 3482,
     "src/cli/dispatch.rs": 1513,
     "src/cli/login.rs": 1454,
-    "src/cli/provider_init.rs": 1908
+    "src/cli/provider_init.rs": 1916
   },
   "version": 1
 }

From c3ba239052171b1e4ce6494e9ae4a3e1c5c27cde Mon Sep 17 00:00:00 2001
From: Alejandro Blanco-M <alecuba16@gmail.com>
Date: Sat, 19 Sep 2026 20:55:43 +0200
Subject: [PATCH 21/21] fix(session): persist debug and canary headless
 sessions

The lazy-save guard (9e8d6e13b) skips persistence for sessions with no
visible messages and no explicit state. Debug admin-socket sessions are
empty and untitled at creation, so their first save() was a no-op and
Session::load ENOENTed, breaking the e2e debug flow tests on ubuntu and
macOS. Treat is_debug and is_canary as explicit state, the same way
title (#1144, 363372e2b) and parent linkage (4e7009930) already do.
---
 crates/jcode-base/src/session/persistence.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/crates/jcode-base/src/session/persistence.rs b/crates/jcode-base/src/session/persistence.rs
index 9d4d57198e..ebd32dca61 100644
--- a/crates/jcode-base/src/session/persistence.rs
+++ b/crates/jcode-base/src/session/persistence.rs
@@ -387,6 +387,10 @@ impl Session {
         // id find no file and silently treat the session as missing.
         // Parent linkage is also explicit state: an empty fork carries only a
         // hidden fork notice but must be loadable when its new client attaches.
+        // Debug and canary flags are explicit state too: a headless session
+        // created via the debug admin socket is empty and untitled at creation,
+        // but later lookups by id (e2e flows, resume) must find the file, the
+        // same way title/parent linkage must (4e7009930, #1144).
         if !self.persist_state.snapshot_exists
             && !self
                 .messages
@@ -396,6 +400,8 @@ impl Session {
             && self.custom_title.is_none()
             && self.title.is_none()
             && self.parent_id.is_none()
+            && !self.is_debug
+            && !self.is_canary
         {
             return Ok(());
         }