feat(desktop): developer mode display style — prompt-first UI with pinned/recent channel list, palette, and split-pane side chats

crates/buzz-acp/src/acp.rs

@@ -211,6 +211,10 @@ pub struct AcpClient {
     /// deltas. Both goose and buzz-agent emit this notification; goose gates
     /// on client capability advertisement, buzz-agent emits unconditionally.
     goose_usage: UsageTracker,
+    /// Accumulates `agent_message_chunk` text while a one-shot helper (the
+    /// `complete` subcommand) is capturing the agent's reply. `None` disables
+    /// capture — the normal harness path never allocates here.
+    captured_agent_text: Option<String>,
 }
 
 /// Recursively merge `overlay` into `base`, with `overlay` winning on scalar/shape
@@ -550,9 +554,23 @@ impl AcpClient {
             steering_supported: false,
             steer_rx: None,
             goose_usage: UsageTracker::default(),
+            captured_agent_text: None,
         })
     }
 
+    /// Start capturing `agent_message_chunk` text from `session/update`
+    /// notifications. Used by the one-shot `complete` subcommand to collect
+    /// the agent's reply text; the harness path never enables this.
+    pub fn begin_text_capture(&mut self) {
+        self.captured_agent_text = Some(String::new());
+    }
+
+    /// Take the text captured since [`begin_text_capture`](Self::begin_text_capture)
+    /// and disable capture.
+    pub fn take_captured_text(&mut self) -> String {
+        self.captured_agent_text.take().unwrap_or_default()
+    }
+
     /// Attach a local observer feed to this ACP client.
     pub fn set_observer(&mut self, observer: Option<ObserverHandle>, agent_index: usize) {
         self.observer = observer;
@@ -1715,6 +1733,9 @@ impl AcpClient {
             "agent_message_chunk" => {
                 if let Some(text) = update["content"]["text"].as_str() {
                     tracing::info!(target: "acp::stream", "{text}");
+                    if let Some(buffer) = self.captured_agent_text.as_mut() {
+                        buffer.push_str(text);
+                    }
                 }
                 false
             }

crates/buzz-acp/src/base_prompt.md

@@ -24,6 +24,16 @@ Run `buzz --help` or `buzz <group> --help` for full usage. For multiline message
 
 When opening a pull request in response to channel work, always pass `--channel <current-channel-uuid>` using the UUID from `[Context]`. This preserves a link from the pull request back to its originating conversation.
 
+## Sub-channels
+
+Sub-channels are focused working sessions under a main channel. They use the one-level naming convention `parent--sub`; a sub-channel cannot itself be a parent.
+
+Spawn one with `buzz channels create --name <slug> --parent <parent-channel-id> --description "<task>"`. The sub-channel inherits the parent's type and visibility; the command constructs the full name, announces the spawn in the parent, and updates both canvases.
+
+Only ever add someone to a sub-channel if they are already a member of its parent. Humans may join a sub-channel to steer the work or stay out of it.
+
+Before considering the task done, post a final summary to the parent channel as a thread reply to the spawn announcement. The sub-channel canvas records both the parent channel and the announcement event ID under `spawned-from`.
+
 ## Conversational Agent Creation
 
 When someone asks to create an agent, ask for at most two things: the agent's name and what it should do day-to-day. Turn the user's rough purpose into the `--system-prompt` yourself; do not separately ask for purpose, tone, constraints, access, runtime, provider, or model unless the user's request is genuinely ambiguous.

crates/buzz-acp/src/config.rs

@@ -201,6 +201,35 @@ pub struct AuthAgentArgs {
     pub agent_args: Vec<String>,
 }
 
+/// CLI args for `buzz-acp complete` — one-shot prompt completion via the
+/// configured agent. Spawns the agent, opens a session, sends a single
+/// prompt, and prints the accumulated agent reply text. No relay connection.
+#[derive(Debug, Parser)]
+#[command(
+    name = "buzz-acp complete",
+    about = "One-shot prompt completion via the configured agent"
+)]
+pub struct CompleteArgs {
+    #[command(flatten)]
+    pub agent: AuthAgentArgs,
+
+    /// Prompt text to send to the agent.
+    #[arg(long)]
+    pub prompt: String,
+
+    /// Optional system prompt for the session.
+    #[arg(long)]
+    pub system_prompt: Option<String>,
+
+    /// Optional model id to select via `session/set_model` (best-effort).
+    #[arg(long)]
+    pub model: Option<String>,
+
+    /// Output structured JSON (`{"text": ...}`) instead of raw text.
+    #[arg(long)]
+    pub json: bool,
+}
+
 /// CLI args for `buzz-acp auth-methods` — query adapter-advertised login methods.
 #[derive(Debug, Parser)]
 #[command(

crates/buzz-acp/src/lib.rs

@@ -30,7 +30,7 @@ use buzz_core::observer::{
 };
 use clap::Parser;
 use config::{
-    AuthAgentArgs, AuthMethodsArgs, AuthenticateArgs, Config, DedupMode, ModelsArgs,
+    AuthAgentArgs, AuthMethodsArgs, AuthenticateArgs, CompleteArgs, Config, DedupMode, ModelsArgs,
     MultipleEventHandling, RespondTo, SubscribeMode,
 };
 use filter::SubscriptionRule;
@@ -1251,6 +1251,16 @@ async fn tokio_main() -> Result<()> {
         return run_models(args).await;
     }
 
+    if is_subcommand("complete") {
+        let filtered: Vec<String> = std::env::args()
+            .enumerate()
+            .filter(|(i, _)| *i != 1)
+            .map(|(_, a)| a)
+            .collect();
+        let args = CompleteArgs::parse_from(&filtered);
+        return run_complete(args).await;
+    }
+
     if is_subcommand("auth-methods") {
         let filtered: Vec<String> = std::env::args()
             .enumerate()
@@ -4176,6 +4186,98 @@ async fn run_models(args: ModelsArgs) -> Result<()> {
     Ok(())
 }
 
+/// Setup timeout for `buzz-acp complete` (spawn + initialize + session/new).
+/// Longer than [`MODELS_TIMEOUT`] because agents cold-start here (goose can
+/// take >10s to initialize its first session).
+const COMPLETE_SETUP_TIMEOUT: Duration = Duration::from_secs(30);
+
+/// Idle timeout for `buzz-acp complete` — resets on any agent stdout activity.
+const COMPLETE_IDLE_TIMEOUT: Duration = Duration::from_secs(30);
+
+/// Hard wall-clock cap for `buzz-acp complete`.
+const COMPLETE_MAX_DURATION: Duration = Duration::from_secs(90);
+
+/// Flow: spawn → initialize → session/new → session/prompt → print captured
+/// agent text → shutdown. No relay connection, no MCP servers.
+///
+/// Powers desktop features that need a bounded request/response completion
+/// from the configured agent (e.g. Developer Mode channel naming).
+async fn run_complete(args: CompleteArgs) -> Result<()> {
+    let agent_args = config::normalize_agent_args(&args.agent.agent_command, args.agent.agent_args);
+    let cwd = std::env::current_dir()
+        .unwrap_or_else(|_| std::path::PathBuf::from("/"))
+        .to_string_lossy()
+        .to_string();
+
+    // Spawn outside the timeout so we always own the child for cleanup.
+    let mut client =
+        match AcpClient::spawn(&args.agent.agent_command, &agent_args, &[], false).await {
+            Ok(c) => c,
+            Err(e) => {
+                eprintln!("error: failed to spawn agent: {e}");
+                std::process::exit(1);
+            }
+        };
+
+    let setup_result = tokio::time::timeout(COMPLETE_SETUP_TIMEOUT, async {
+        client.initialize().await?;
+        let session = client
+            .session_new_full(&cwd, vec![], args.system_prompt.as_deref(), None)
+            .await?;
+        Ok::<_, acp::AcpError>(session.session_id)
+    })
+    .await;
+
+    let session_id = match setup_result {
+        Ok(Ok(id)) => id,
+        Ok(Err(e)) => {
+            client.shutdown().await;
+            eprintln!("error: agent communication failed: {e}");
+            std::process::exit(1);
+        }
+        Err(_) => {
+            client.shutdown().await;
+            eprintln!("error: agent timed out ({COMPLETE_SETUP_TIMEOUT:?})");
+            std::process::exit(1);
+        }
+    };
+
+    // Best-effort model selection — not all agents support session/set_model.
+    if let Some(model) = &args.model {
+        let _ = client.session_set_model(&session_id, model).await;
+    }
+
+    client.begin_text_capture();
+    let prompt_result = client
+        .session_prompt_with_idle_timeout(
+            &session_id,
+            &args.prompt,
+            COMPLETE_IDLE_TIMEOUT,
+            COMPLETE_MAX_DURATION,
+        )
+        .await;
+    let text = client.take_captured_text();
+    client.shutdown().await;
+
+    if let Err(e) = prompt_result {
+        eprintln!("error: prompt failed: {e}");
+        std::process::exit(1);
+    }
+
+    let trimmed = text.trim();
+    if trimmed.is_empty() {
+        eprintln!("error: agent returned no message text");
+        std::process::exit(1);
+    }
+
+    if args.json {
+        println!("{}", serde_json::json!({ "text": trimmed }));
+    } else {
+        println!("{trimmed}");
+    }
+    Ok(())
+}
+
 fn build_mcp_servers(config: &Config) -> Vec<McpServer> {
     if config.mcp_command.is_empty() {
         return vec![];