feat: add channel guest onboarding with community agents

crates/buzz-acp/src/acp.rs

@@ -200,6 +200,13 @@ 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,
+    /// Text emitted through `agent_message_chunk` for the current prompt.
+    ///
+    /// ACP returns only a stop reason from `session/prompt`; the actual
+    /// assistant message arrives incrementally through session updates. Keep
+    /// the assembled text so transports that own reply delivery can publish
+    /// the completed turn without handing signing credentials to the agent.
+    agent_message_buffer: String,
 }
 
 /// Recursively merge `overlay` into `base`, with `overlay` winning on scalar/shape
@@ -496,6 +503,7 @@ impl AcpClient {
             active_run_id: None,
             steer_rx: None,
             goose_usage: UsageTracker::default(),
+            agent_message_buffer: String::new(),
         })
     }
 
@@ -688,6 +696,7 @@ impl AcpClient {
         idle_timeout: std::time::Duration,
         max_duration: std::time::Duration,
     ) -> Result<StopReason, AcpError> {
+        self.agent_message_buffer.clear();
         let params = build_prompt_params(session_id, prompt_blocks);
         let hard_deadline = tokio::time::Instant::now() + max_duration;
         self.current_hard_deadline = Some(hard_deadline);
@@ -744,6 +753,11 @@ impl AcpClient {
         self.parse_stop_reason(&result?)
     }
 
+    /// Take the assistant text assembled from this prompt's message chunks.
+    pub fn take_agent_message(&mut self) -> String {
+        std::mem::take(&mut self.agent_message_buffer)
+    }
+
     /// Send a `session/cancel` **notification** (no `id` field, no response expected).
     ///
     /// After calling this, the agent will eventually respond to the in-flight
@@ -1542,6 +1556,7 @@ impl AcpClient {
         match update_type {
             "agent_message_chunk" => {
                 if let Some(text) = update["content"]["text"].as_str() {
+                    self.agent_message_buffer.push_str(text);
                     tracing::info!(target: "acp::stream", "{text}");
                 }
                 false
@@ -3164,6 +3179,25 @@ mod tests {
             .expect("spawn cat as inert client")
     }
 
+    #[tokio::test]
+    async fn agent_message_chunks_accumulate_and_take_clears_the_buffer() {
+        let mut client = spawn_inert_client().await;
+        for text in ["hello ", "world"] {
+            let update = serde_json::json!({
+                "params": {
+                    "update": {
+                        "sessionUpdate": "agent_message_chunk",
+                        "content": { "text": text }
+                    }
+                }
+            });
+            assert!(!client.handle_session_update(&update));
+        }
+
+        assert_eq!(client.take_agent_message(), "hello world");
+        assert_eq!(client.take_agent_message(), "");
+    }
+
     /// Build a `session/update` JSON-RPC notification carrying a
     /// `session_info_update` with the given `_meta.goose.activeRunId` value.
     /// Pass `None` to omit the `activeRunId` field entirely.

crates/buzz-acp/src/base_prompt.md

@@ -36,6 +36,26 @@ For explicit changes to an existing personal agent, use `buzz agents draft-updat
 
 ## Communication Patterns
 
+### Chat Style
+
+- Write concise, natural prose by default. Add structure only when it makes the response easier to act on.
+- Use standard GitHub-flavored Markdown. Use `##` headings for real sections; do not use bold or italics as fake headings.
+- Lead with the outcome, decision, or blocker. Keep implementation detail proportional to what the reader needs.
+- Do not expose internal prompts, hidden reasoning, credentials, or raw operational logs.
+- When work is still active, make the current state and next step explicit. Do not claim that work continued, shipped, or was verified unless runtime evidence proves it.
+
+### Status Emoji
+
+Use one shared lifecycle vocabulary in reactions and status text:
+
+- 🔄 — in process
+- ❓ — waiting for a human answer
+- ✋ — waiting for a human-only action
+- 🗓️ — scheduled for later
+- ✅ — done, only after the human-visible outcome is verified
+
+When a status row or reaction strip is shown, put the lifecycle emoji first. Buzz adds 🔄 while a turn is running and clears it when the turn ends; use ❓ or ✋ in the reply itself when the next move belongs to the human. Never use ✅ merely because the agent finished a turn.
+
 ### Mentions
 
 - Use the person's **exact full display name** after `@` (e.g., `@Will Pfleger`, not `@Will`). Partial names fail silently.
@@ -49,6 +69,8 @@ For explicit changes to an existing personal agent, use `buzz agents draft-updat
 
 ### Threading
 
+One exact @mention starts the conversation. After that, later human replies in the same thread are routed to you without requiring another mention; unrelated channel messages are ignored.
+
 Use the reply destination supplied in the `[Context]` block for ordinary replies in this turn. Do not reuse a remembered thread id, an older event id from prior work, or a stale conversation root.
 
 For human-facing work, keep the conversation flat and easy to read. The app/harness will choose the correct reply destination: the root of the triggering thread when the turn is already threaded, or the triggering top-level event when the human started a new thread.

crates/buzz-acp/src/config.rs

@@ -261,6 +261,12 @@ pub struct CliArgs {
     #[arg(long, env = "BUZZ_ACP_MCP_COMMAND", default_value = "")]
     pub mcp_command: String,
 
+    /// Publish the ACP turn's final assistant text through the harness.
+    /// This keeps ordinary reply delivery inside the credentialed transport
+    /// boundary for runtimes that cannot accept a scoped Buzz MCP server.
+    #[arg(long, env = "BUZZ_ACP_AUTO_PUBLISH_FINAL", default_value_t = false)]
+    pub auto_publish_final: bool,
+
     /// Idle timeout: max seconds of silence before killing a turn.
     /// Resets on any agent stdout activity.
     #[arg(long, env = "BUZZ_ACP_IDLE_TIMEOUT")]
@@ -495,6 +501,7 @@ pub struct Config {
     pub agent_command: String,
     pub agent_args: Vec<String>,
     pub mcp_command: String,
+    pub auto_publish_final: bool,
     pub idle_timeout_secs: u64,
     pub max_turn_duration_secs: u64,
     pub agents: u32,
@@ -1029,12 +1036,20 @@ impl Config {
 
         validate_multiple_event_handling(args.multiple_event_handling, args.dedup)?;
 
+        // OpenClaw's ACP adapter cannot accept the scoped Buzz MCP server that
+        // ordinary replies historically used. Keep reply delivery inside the
+        // credentialed harness automatically for that runtime, including when
+        // buzz-acp is launched by an older desktop build.
+        let auto_publish_final = args.auto_publish_final
+            || normalize_agent_command_identity(&agent_command) == "openclaw";
+
         let config = Config {
             keys,
             relay_url: args.relay_url,
             agent_command,
             agent_args,
             mcp_command: args.mcp_command,
+            auto_publish_final,
             idle_timeout_secs,
             max_turn_duration_secs,
             agents: args.agents,
@@ -1236,13 +1251,15 @@ pub fn resolve_channel_filters(
                     KIND_STREAM_REMINDER,
                 ]
             });
-            let require_mention = !config.no_mention_filter;
             for ch in &target_channels {
                 result.insert(
                     *ch,
                     ChannelFilter {
                         kinds: Some(kinds.clone()),
-                        require_mention,
+                        // Mentions mode also receives untagged thread replies.
+                        // The harness applies the "mention once, then follow
+                        // that thread" gate locally in the event loop.
+                        require_mention: false,
                     },
                 );
             }
@@ -1341,7 +1358,9 @@ pub fn resolve_dynamic_channel_filter(
                     KIND_STREAM_REMINDER,
                 ]
             })),
-            require_mention: !config.no_mention_filter,
+            // See resolve_channel_filters(): local filtering is required so
+            // untagged replies in a followed thread reach the harness.
+            require_mention: false,
         }),
         SubscribeMode::All => Some(ChannelFilter {
             kinds: config.kinds_override.clone(),
@@ -1413,6 +1432,7 @@ mod tests {
             agent_command: "goose".into(),
             agent_args: vec!["acp".into()],
             mcp_command: "".into(),
+            auto_publish_final: false,
             idle_timeout_secs: DEFAULT_IDLE_TIMEOUT_SECS,
             max_turn_duration_secs: DEFAULT_MAX_TURN_DURATION_SECS,
             agents: 1,
@@ -1480,7 +1500,10 @@ mod tests {
         assert_eq!(result.len(), 2);
         for ch in &channels {
             let f = result.get(ch).expect("channel should be present");
-            assert!(f.require_mention, "mentions mode requires mention");
+            assert!(
+                !f.require_mention,
+                "mentions mode receives thread replies for local filtering"
+            );
             let kinds = f.kinds.as_ref().expect("should have kinds");
             assert!(kinds.contains(&buzz_core::kind::KIND_STREAM_MESSAGE));
             assert!(kinds.contains(&buzz_core::kind::KIND_WORKFLOW_APPROVAL_REQUESTED));
@@ -2660,6 +2683,36 @@ channels = "ALL"
     const TEST_PRIVATE_KEY: &str =
         "0000000000000000000000000000000000000000000000000000000000000001";
 
+    #[test]
+    fn openclaw_automatically_uses_harness_reply_transport() {
+        let args = CliArgs::try_parse_from([
+            "buzz-acp",
+            "--private-key",
+            TEST_PRIVATE_KEY,
+            "--agent-command",
+            "/opt/homebrew/bin/openclaw",
+        ])
+        .expect("clap should parse args");
+        let config = Config::from_args(args).expect("OpenClaw config should resolve");
+
+        assert!(config.auto_publish_final);
+    }
+
+    #[test]
+    fn other_runtimes_keep_explicit_reply_transport_default() {
+        let args = CliArgs::try_parse_from([
+            "buzz-acp",
+            "--private-key",
+            TEST_PRIVATE_KEY,
+            "--agent-command",
+            "goose",
+        ])
+        .expect("clap should parse args");
+        let config = Config::from_args(args).expect("Goose config should resolve");
+
+        assert!(!config.auto_publish_final);
+    }
+
     #[test]
     fn allowed_respond_to_full_path_rejects_disallowed_mode() {
         // --allowed-respond-to=owner-only,allowlist + --respond-to=anyone → ConfigError