Merge remote-tracking branch 'origin/zs/main' into feat/mcp-registry-core

Signed-off-by: wiggdevin <202901685+wiggdevin@users.noreply.github.com>

Author: wiggdevin

crates/buzz-acp/Cargo.toml

@@ -15,6 +15,13 @@ path = "src/lib.rs"
 name = "buzz-acp"
 path = "src/main.rs"
 
+[features]
+# Re-exports the `session/new` delivery seam as `buzz_acp::delivery_seam` so the
+# desktop crate's end-to-end prompt-source test can drive the real harness path
+# instead of restating it. Enabled only by that dev-dependency; off in every
+# shipped build of this crate.
+delivery-seam-test-api = []
+
 [dependencies]
 # Internal
 buzz-core = { workspace = true }

crates/buzz-acp/src/acp.rs

@@ -3507,6 +3507,108 @@ mod tests {
         );
     }
 
+    /// The delivery seam, harness half: a prompt reloaded from a file on the
+    /// desktop must reach the ACP `session/new` request byte-for-byte after the
+    /// agent restarts.
+    ///
+    /// A restart writes the definition's prompt into `BUZZ_ACP_SYSTEM_PROMPT`,
+    /// which lands in `Config::system_prompt`, is framed by
+    /// `pool::combined_system_prompt` and handed to `session_new_full` through
+    /// `pool::session_new_system_prompt`. This drives real file bytes through
+    /// that composition and that transport choice, and asserts what the adapter
+    /// actually receives, for both framings. The adapter does not receive the
+    /// bare file — the harness frames it in `<system>` — so the falsifiable
+    /// claim is that the file's bytes survive the framing verbatim.
+    ///
+    /// This test guards the harness on its own (`cargo test -p buzz-acp`, with
+    /// no desktop build). The whole chain from the file on disk through the
+    /// desktop reload and restart into this request is
+    /// `a_reloaded_prompt_file_reaches_the_adapter_after_a_restart` in
+    /// `desktop/src-tauri/src/commands/personas/prompt_source/tests.rs`.
+    #[tokio::test]
+    async fn session_new_delivers_reloaded_prompt_source_file_bytes() {
+        // Layout characters, non-ASCII and a trailing newline: everything a
+        // hand-edited prompt file carries that a naive trim would eat.
+        let file_text = "You are the PM.\n\n\tKeep a decision log — ünïcode, emoji 🐝.\n";
+        let path = std::env::temp_dir().join(format!(
+            "buzz-prompt-source-{}-{}.md",
+            std::process::id(),
+            uuid::Uuid::new_v4()
+        ));
+        std::fs::write(&path, file_text).expect("write prompt file");
+        let prompt = std::fs::read_to_string(&path).expect("read prompt file back");
+        std::fs::remove_file(&path).ok();
+        assert_eq!(prompt, file_text, "the reload carries the file's bytes");
+
+        // `read -r`: without it bash eats the backslashes in the JSON string
+        // escapes, and the echo-back would corrupt exactly the bytes under test.
+        let script = r#"
+            read -r -t 2 _init
+            echo '{"jsonrpc":"2.0","id":0,"result":{"protocolVersion":2,"agentCapabilities":{}}}'
+            read -r -t 2 REQ
+            printf '%s\n' '{"jsonrpc":"2.0","id":1,"result":{"sessionId":"ses_reload","_receivedRequest":'"$REQ"'}}'
+            sleep 1
+        "#;
+
+        // A base prompt is present, as on every spawn that does not pass
+        // `--no-base-prompt`, so this asserts the file's bytes survive the
+        // framing rather than asserting the framing is absent.
+        let composed = crate::pool::combined_system_prompt(
+            "/tmp",
+            Some("Base harness instructions."),
+            Some(prompt.as_str()),
+            None,
+            None,
+            None,
+            None,
+        )
+        .expect("a system prompt composes");
+        assert!(
+            composed.contains(file_text),
+            "the composed prompt must carry the file's bytes verbatim: {composed:?}"
+        );
+
+        // Field framing (buzz-agent and every non-Claude adapter on v2).
+        let mut client = spawn_script(script).await;
+        client
+            .initialize()
+            .await
+            .expect("initialize should succeed");
+        let transport =
+            crate::pool::session_new_system_prompt(false, 2, "buzz-agent", Some(composed.as_str()));
+        let resp = client
+            .session_new_full("/tmp", vec![], transport, None)
+            .await
+            .expect("session_new_full should succeed");
+        assert_eq!(
+            resp.raw["_receivedRequest"]["params"]["systemPrompt"].as_str(),
+            Some(composed.as_str()),
+            "the adapter must receive the prompt file's bytes unchanged"
+        );
+
+        // Claude framing keeps the adapter's own preset and appends ours.
+        let mut client = spawn_script(script).await;
+        client
+            .initialize()
+            .await
+            .expect("initialize should succeed");
+        let transport = crate::pool::session_new_system_prompt(
+            false,
+            2,
+            crate::pool::CLAUDE_AGENT_ACP_NAME,
+            Some(composed.as_str()),
+        );
+        let resp = client
+            .session_new_full("/tmp", vec![], transport, None)
+            .await
+            .expect("session_new_full should succeed");
+        assert_eq!(
+            resp.raw["_receivedRequest"]["params"]["_meta"]["systemPrompt"]["append"].as_str(),
+            Some(composed.as_str()),
+            "the Claude framing must append the prompt file's bytes unchanged"
+        );
+    }
+
     #[tokio::test]
     async fn goose_system_prompt_request_uses_set_contract() {
         let script = r#"

crates/buzz-acp/src/lib.rs

@@ -28,6 +28,35 @@ pub use config::Config;
 pub use config::ConfigError;
 pub use usage::TurnUsage;
 
+/// The `session/new` delivery seam, re-exported for cross-crate end-to-end tests.
+///
+/// Every item here is production code on the path a spawned harness takes from
+/// its environment to the adapter's `session/new` request: the CLI/env parse
+/// that reads `BUZZ_ACP_SYSTEM_PROMPT` ([`CliArgs`](delivery_seam::CliArgs) and
+/// [`Config::from_args`](delivery_seam::Config::from_args)),
+/// the standing-prompt composition
+/// ([`combined_system_prompt`](delivery_seam::combined_system_prompt)), the
+/// per-adapter transport choice
+/// ([`session_new_system_prompt`](delivery_seam::session_new_system_prompt)),
+/// and the client that puts the request on the wire
+/// ([`AcpClient`](delivery_seam::AcpClient)). Nothing here is written for a
+/// test; the module only widens where those items can be reached from.
+///
+/// Gated on the `delivery-seam-test-api` feature, which only
+/// `desktop/src-tauri`'s dev-dependency turns on, so no shipped build of this
+/// crate gains public API.
+#[cfg(feature = "delivery-seam-test-api")]
+pub mod delivery_seam {
+    pub use crate::acp::{AcpClient, SessionNewResponse, SystemPromptTransport};
+    pub use crate::config::{CliArgs, Config};
+    pub use crate::pool::{
+        combined_system_prompt, session_new_system_prompt, CLAUDE_AGENT_ACP_NAME,
+    };
+    /// `clap`'s trait, so a caller can reach `CliArgs::try_parse_from` without
+    /// depending on the same `clap` release this crate resolved.
+    pub use clap::Parser;
+}
+
 use std::collections::{HashMap, HashSet, VecDeque};
 use std::sync::Arc;
 use std::time::Duration;

crates/buzz-acp/src/pool.rs

@@ -279,7 +279,7 @@ pub struct OwnedAgent {
 /// on `session/new` — the feature landed in v0.6.0 (Oct 2025), before the
 /// `@zed-industries/claude-code-acp` → `@agentclientprotocol/claude-agent-acp`
 /// rename, so the new name is a reliable capability gate.
-const CLAUDE_AGENT_ACP_NAME: &str = "@agentclientprotocol/claude-agent-acp";
+pub const CLAUDE_AGENT_ACP_NAME: &str = "@agentclientprotocol/claude-agent-acp";
 
 fn has_system_prompt_support(
     protocol_version: u32,
@@ -295,7 +295,11 @@ fn has_system_prompt_support(
     }
 }
 
-fn session_new_system_prompt<'a>(
+/// The `session/new` system-prompt transport for an adapter.
+///
+/// Public within the crate facade so a delivery-seam test can put a prompt
+/// through the same choice production makes, rather than restating it.
+pub fn session_new_system_prompt<'a>(
     is_goose: bool,
     protocol_version: u32,
     agent_name: &str,
@@ -1279,21 +1283,13 @@ async fn create_session_and_apply_model(
     // its own `<core-memory>` boundary, and canvas carries its own
     // `<channel-canvas>` boundary; both are appended with a blank-line separator.
     let is_goose = agent.agent_name == "goose";
-    let combined_system_prompt = with_canvas(
-        with_huddle_instructions(
-            with_core(
-                with_team(
-                    framed_system_prompt(
-                        &ctx.cwd,
-                        ctx.base_prompt.as_deref(),
-                        ctx.system_prompt.as_deref(),
-                    ),
-                    ctx.team_instructions.as_deref(),
-                ),
-                agent_core,
-            ),
-            channel.huddle_instructions,
-        ),
+    let combined_system_prompt = combined_system_prompt(
+        &ctx.cwd,
+        ctx.base_prompt.as_deref(),
+        ctx.system_prompt.as_deref(),
+        ctx.team_instructions.as_deref(),
+        agent_core,
+        channel.huddle_instructions,
         channel.canvas,
     );
 
@@ -1854,6 +1850,40 @@ pub(crate) fn prepend_standing_for_legacy(
 /// agent instructions. A persona-only agent still yields
 /// `<system>…</system>` rather than an unlabeled blob that would be mistaken
 /// for `<base>`.
+/// The standing system prompt one `session/new` carries.
+///
+/// The agent's own instructions are framed with the base prompt and workspace
+/// section, then the team, core-memory, huddle and canvas sections are appended
+/// in that order. Every section body is preserved byte-for-byte, so a prompt
+/// loaded from a file reaches the adapter exactly as written.
+///
+/// This is the whole composition `create_session_and_apply_model` performs; it
+/// is a named function so a caller outside this module can drive the same
+/// composition production does instead of restating the nesting.
+pub fn combined_system_prompt(
+    cwd: &str,
+    base_prompt: Option<&str>,
+    system_prompt: Option<&str>,
+    team_instructions: Option<&str>,
+    agent_core: Option<&str>,
+    huddle_instructions: Option<&str>,
+    canvas: Option<&str>,
+) -> Option<String> {
+    with_canvas(
+        with_huddle_instructions(
+            with_core(
+                with_team(
+                    framed_system_prompt(cwd, base_prompt, system_prompt),
+                    team_instructions,
+                ),
+                agent_core,
+            ),
+            huddle_instructions,
+        ),
+        canvas,
+    )
+}
+
 fn framed_system_prompt(
     cwd: &str,
     base_prompt: Option<&str>,