Tcode Chat UI v2

.github/workflows/ci.yml

@@ -4,6 +4,7 @@ on:
   push:
     branches: [main]
   pull_request:
+    types: [opened, synchronize, reopened, ready_for_review]
   # Pull requests opened with GITHUB_TOKEN start no pull_request run; the
   # agent-version workflow dispatches one instead.
   workflow_dispatch:
@@ -28,6 +29,7 @@ jobs:
   # required check must wait for that platform's Clippy and tests alone.
   linux-clippy:
     name: Linux x64 / clippy
+    if: !github.event.pull_request.draft
     runs-on: ubuntu-24.04
     timeout-minutes: 60
     steps: &clippy-steps
@@ -123,6 +125,7 @@ jobs:
 
   linux-tests:
     name: Linux x64 / tests
+    if: !github.event.pull_request.draft
     runs-on: ubuntu-24.04
     timeout-minutes: 60
     steps: &test-steps
@@ -178,24 +181,28 @@ jobs:
 
   macos-clippy:
     name: macOS arm64 / clippy
+    if: !github.event.pull_request.draft
     runs-on: macos-26
     timeout-minutes: 60
     steps: *clippy-steps
 
   macos-tests:
     name: macOS arm64 / tests
+    if: !github.event.pull_request.draft
     runs-on: macos-26
     timeout-minutes: 60
     steps: *test-steps
 
   windows-clippy:
     name: Windows x64 / clippy
+    if: !github.event.pull_request.draft
     runs-on: windows-2022
     timeout-minutes: 60
     steps: *clippy-steps
 
   windows-tests:
     name: Windows x64 / tests
+    if: !github.event.pull_request.draft
     runs-on: windows-2022
     timeout-minutes: 60
     steps: *test-steps
@@ -204,8 +211,9 @@ jobs:
   # must not let its platform's check pass.
   linux:
     name: Linux x64
+    if: !github.event.pull_request.draft
     needs: [linux-clippy, linux-tests]
-    if: always()
+    if: always() && !github.event.pull_request.draft
     runs-on: ubuntu-24.04
     timeout-minutes: 5
     steps: &require-platform
@@ -216,22 +224,25 @@ jobs:
 
   macos:
     name: macOS arm64
+    if: !github.event.pull_request.draft
     needs: [macos-clippy, macos-tests]
-    if: always()
+    if: always() && !github.event.pull_request.draft
     runs-on: ubuntu-24.04
     timeout-minutes: 5
     steps: *require-platform
 
   windows:
     name: Windows x64
+    if: !github.event.pull_request.draft
     needs: [windows-clippy, windows-tests]
-    if: always()
+    if: always() && !github.event.pull_request.draft
     runs-on: ubuntu-24.04
     timeout-minutes: 5
     steps: *require-platform
 
   dependencies:
     name: Dependency hygiene
+    if: !github.event.pull_request.draft
     runs-on: ubuntu-24.04
     timeout-minutes: 10
     steps:
@@ -247,6 +258,7 @@ jobs:
 
   ios:
     name: iOS
+    if: !github.event.pull_request.draft
     runs-on: macos-26
     timeout-minutes: 30
     env:
@@ -270,6 +282,7 @@ jobs:
 
   android:
     name: Android
+    if: !github.event.pull_request.draft
     runs-on: ubuntu-24.04
     timeout-minutes: 30
     env:
@@ -316,6 +329,7 @@ jobs:
 
   web:
     name: Web
+    if: !github.event.pull_request.draft
     runs-on: ubuntu-24.04
     timeout-minutes: 30
     env:

CONTRIBUTING.md

@@ -54,22 +54,33 @@ is derived from it. **Process** is how to build, check and submit work.
 
 6. **gpui-base is the infrastructure; no house UI principles.** Tcode follows
    the recommendations and defaults of gpui-base and gpui-kit, and keeps no
-   separate design contract in sync with the code. Everything gpui-base
+   separate design contract in sync with the code: no house-wide UI rules of
+   its own, such as a single duration for every transition or classes of
+   change that must stay instant. Everything gpui-base
    provides on top of GPUI — selection, scrolling, positioning, dismissal,
    focus, theme tokens, motion, virtual lists, form controls — is used as it
    is, defaults included, before anything of the kind is written in Tcode.
    Tcode's own components are styled compositions of those primitives; they
-   never re-derive a primitive's rules locally. A primitive is reimplemented,
-   or a default overridden, only where gpui-base demonstrably cannot meet the
-   need; the site names that gap, and it is removed once gpui-base closes it.
+   never re-derive a primitive's rules locally. Where gpui-base demonstrably
+   cannot meet the need, Tcode builds what is missing — a primitive
+   reimplemented, a default overridden, or an element gpui-base does not have
+   — and the site names that gap; it is removed once gpui-base closes it.
+   This principle decides how something is built, never whether it is built:
+   what the interface does is the maintainer's call, and a primitive
+   gpui-base lacks is never a reason to leave an effect out, make it instant,
+   or settle for less.
 
 7. **Code and tests are the only source of truth.** This section is the only
    maintainer-authored text; comments, issues and other documents are derived
    from it and are corrected when they disagree with it or with the code. A
    comment is kept only when it states a constraint the code cannot express or
    the reason an obvious alternative was rejected; narrated steps, history and
    "mirrors X" notes are deleted when touched. A constraint drafted by an AI is
-   not a requirement until it appears here. A test, whatever its form, is
+   not a requirement until it appears here. Rules and conventions written into
+   audits, hand-offs, briefs or agent instructions bind no one: they are
+   notes, never cited as requirements or used to send work back, and where
+   one would narrow what the maintainer asked for, the maintainer's request
+   wins. A test, whatever its form, is
    truth only for a contract real use needs, and only while it is the test
    that proves it by driving the code the way the running app does. The suite
    is larger than its contracts: a test met while working on its area is

clippy.toml

@@ -6,5 +6,7 @@
 disallowed-methods = [
     { path = "std::process::Command::new", reason = "use services::process::command or agent's process::command so Windows never flashes a console" },
     { path = "smol::process::Command::new", reason = "use services::process::async_command or agent's process::async_command so Windows never flashes a console" },
+    { path = "gpui::StatefulInteractiveElement::tooltip", reason = "use tcode_ui::widgets::TooltipTrigger::with_tooltip so the tooltip shows through the window's tooltip layer and can leave" },
+    { path = "gpui::InteractiveText::tooltip", reason = "track the text's parts with widgets::tooltip::track_parts so the tooltip shows through the window's tooltip layer and can leave" },
     { path = "smol::unblock", reason = "use Host::unblock or the agent crate's process::unblock so blocking work is scheduled in one place" },
 ]

crates/agent/Cargo.toml

@@ -7,7 +7,6 @@ edition = "2024"
 default = ["process"]
 process = [
     "dep:agent-client-protocol",
-    "dep:base64",
     "dep:dirs",
     "dep:sha2",
     "dep:smol",
@@ -22,7 +21,7 @@ agent-client-protocol = { version = "2.0", optional = true, features = [
     "unstable_end_turn_token_usage",
 ] }
 log = "0.4"
-base64 = { version = "0.23", optional = true }
+base64 = "0.23"
 dirs = { version = "7", optional = true }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"

crates/agent/examples/probe.rs

@@ -10,7 +10,8 @@
 //! Turn mode: `probe <provider> <prompt> [cwd] [acp-command args…] [flags]`.
 //! Flags are `--binary <path>`, `--model <id>`, `--option <id>=<value>`, `--effort <value>`,
 //! `--resume <cursor-json>`, `--fork`, `--leave-questions` (user-input requests
-//! stay unanswered), `--mcp <name> <url> <token>` (an HTTP MCP server registered
+//! stay unanswered), `--plan-feedback <words>` (the first plan decision is
+//! answered with these words instead of approved), `--mcp <name> <url> <token>` (an HTTP MCP server registered
 //! as tcode registers its own), `--linger <seconds>` (stay open until no turn has
 //! run for that long, to see turns the agent starts itself), `--follow-up
 //! <seconds> <prompt>` (send another turn that long after the first completes,
@@ -231,6 +232,7 @@ fn main() {
     let mut resume = None;
     let mut fork = false;
     let mut leave_questions = false;
+    let mut plan_feedback = None;
     let mut mcp_servers = Vec::new();
     let mut continuation = Continuation::default();
     let mut probe_mode = ProbeMode::Standard;
@@ -261,6 +263,7 @@ fn main() {
             "--fork" => fork = true,
             "--goal" => set_mode(&mut probe_mode, ProbeMode::Goal),
             "--leave-questions" => leave_questions = true,
+            "--plan-feedback" => plan_feedback = args.next(),
             "--linger" => {
                 let seconds = args.next().and_then(|value| value.parse().ok());
                 continuation.linger = Some(Duration::from_secs(seconds.unwrap_or_else(|| usage())));
@@ -350,6 +353,7 @@ fn main() {
             resume,
             fork,
             leave_questions,
+            plan_feedback,
         },
         binary,
         model,
@@ -361,6 +365,7 @@ struct Resumption {
     resume: Option<ResumeCursor>,
     fork: bool,
     leave_questions: bool,
+    plan_feedback: Option<String>,
 }
 
 #[derive(Default)]
@@ -380,7 +385,7 @@ async fn run_probe(
     acp: Option<AcpAgent>,
     mcp_servers: Vec<McpRegistration>,
     continuation: Continuation,
-    resumption: Resumption,
+    mut resumption: Resumption,
     binary_path: Option<PathBuf>,
     model: Option<String>,
 ) -> i32 {
@@ -539,16 +544,21 @@ async fn run_probe(
         }
         match &event {
             AgentEvent::ApprovalRequested(request) => {
+                let feedback = matches!(request.kind, agent::ApprovalKind::Plan { .. })
+                    .then(|| resumption.plan_feedback.take())
+                    .flatten();
                 handle
                     .commands
                     .send(SessionCommand::RespondApproval {
                         request_id: request.id.clone(),
-                        decision: request
-                            .options
-                            .iter()
-                            .find(|option| option.kind == agent::ApprovalOptionKind::AllowOnce)
-                            .map(|option| ApprovalDecision::Option(option.id.clone()))
-                            .unwrap_or(ApprovalDecision::Cancel),
+                        decision: feedback.map(ApprovalDecision::Feedback).unwrap_or_else(|| {
+                            request
+                                .options
+                                .iter()
+                                .find(|option| option.kind == agent::ApprovalOptionKind::AllowOnce)
+                                .map(|option| ApprovalDecision::Option(option.id.clone()))
+                                .unwrap_or(ApprovalDecision::Cancel)
+                        }),
                     })
                     .await
                     .ok();