@team-agent/installer 0.5.113 → 0.5.115

package/crates/team-agent/src/contract_runtime/framework.rs

@@ -0,0 +1,294 @@
+//! Shared-framework seams. A contract seat is never projected as a legacy pane:
+//! its private socket's `%0` must not be interpreted on the workspace tmux server.
+use super::{
+    backend::{self, Backend, BackendError},
+    config,
+};
+use serde_json::{json, Value};
+use std::path::Path;
+use team_agent_contract::contract::types::SeatId;
+use team_agent_contract::host::process::{sample_process, ProcessState};
+use team_agent_contract::orchestration::{
+    operator::OperatorSend,
+    store::{Outcome, SeatStatus},
+};
+
+pub fn is_contract(agent: &Value) -> bool {
+    agent
+        .get("provider")
+        .and_then(Value::as_str)
+        .is_some_and(|provider| super::registry::descriptor(provider).is_some())
+}
+/// Published paused roles without an instance never crossed native startup.
+/// A bound instance is never skipped, even if a stale row says paused.
+pub(crate) fn is_paused_unstarted(agent: &Value) -> bool {
+    is_contract(agent)
+        && agent.get("status").and_then(Value::as_str) == Some("paused")
+        && agent.get("contract_instance").is_none_or(Value::is_null)
+}
+
+pub fn has_contract(state: &Value) -> bool {
+    state
+        .get("agents")
+        .and_then(Value::as_object)
+        .is_some_and(|agents| agents.values().any(is_contract))
+}
+pub fn only_contract(state: &Value) -> bool {
+    state
+        .get("agents")
+        .and_then(Value::as_object)
+        .is_some_and(|agents| !agents.is_empty() && agents.values().all(is_contract))
+}
+/// Unsupported lifecycle operations must stop before the legacy provider enum
+/// can turn an unknown native seat into its historical Codex fallback.
+pub fn require_legacy_lifecycle(
+    workspace: &Path,
+    team: Option<&str>,
+    agent: Option<&str>,
+    operation: &str,
+) -> Result<(), crate::cli::CliError> {
+    let Ok(selected) = crate::state::selector::resolve_active_team_readonly(
+        workspace,
+        team,
+        crate::state::selector::SelectorMode::RuntimeOnly,
+    ) else {
+        return Ok(());
+    };
+    let selected_native = match agent {
+        Some(id) => selected
+            .state
+            .get("agents")
+            .and_then(|agents| agents.get(id))
+            .is_some_and(is_contract),
+        None => has_contract(&selected.state),
+    };
+    let configured_native = selected
+        .state
+        .get("team_dir")
+        .and_then(Value::as_str)
+        .and_then(|directory| {
+            team_config(
+                &selected.run_workspace,
+                Path::new(directory),
+                &selected.team_key,
+            )
+            .ok()
+            .flatten()
+        })
+        .is_some_and(|config| match agent {
+            Some(id) => config.roles.iter().any(|role| role.id.as_str() == id),
+            None => !config.roles.is_empty(),
+        });
+    if selected_native || configured_native {
+        return Err(crate::cli::CliError::Runtime(format!("contract_capability_unverified: {operation} is not admitted for contract-native seats; no legacy fallback or fresh replacement was performed")));
+    }
+    Ok(())
+}
+pub fn require_legacy_role(
+    path: Option<&Path>,
+    provider: Option<&str>,
+) -> Result<(), crate::cli::CliError> {
+    let declared = path
+        .and_then(|path| std::fs::read_to_string(path).ok())
+        .and_then(|raw| {
+            crate::compiler::split_front_matter(&raw)
+                .0
+                .get("provider")
+                .and_then(crate::model::yaml::Value::as_str)
+                .map(str::to_owned)
+        });
+    if provider
+        .or(declared.as_deref())
+        .is_some_and(super::registry::recognizes)
+    {
+        return Err(crate::cli::CliError::Runtime("contract_capability_unverified: mutable contract-native role lifecycle is not admitted; use initial quick-start; no role file was changed".into()));
+    }
+    Ok(())
+}
+pub fn team_config(
+    workspace: &Path,
+    directory: &Path,
+    team: &str,
+) -> Result<Option<config::TeamConfig>, config::ConfigError> {
+    config::read_team(&crate::cli::QuickStartArgs {
+        workspace: workspace.into(),
+        agents_dir: directory.into(),
+        name: None,
+        team_id: Some(team.into()),
+        yes: false,
+        json: false,
+        detail: false,
+        backend: Some("tmux".into()),
+    })
+}
+pub fn start_role(
+    workspace: &Path,
+    directory: &Path,
+    team: &str,
+    id: &str,
+) -> Result<(), crate::lifecycle::LifecycleError> {
+    let error = |error: String| crate::lifecycle::LifecycleError::Provider(error);
+    let config = team_config(workspace, directory, team)
+        .map_err(|e| error(e.to_string()))?
+        .ok_or_else(|| error("contract role no longer configured".into()))?;
+    let role = config
+        .roles
+        .iter()
+        .find(|role| role.id.as_str() == id)
+        .ok_or_else(|| error("contract role not found".into()))?;
+    let (_, record) =
+        backend::start(workspace, team, role, &config.members).map_err(|e| error(e.to_string()))?;
+    if record.outcome != Outcome::Committed {
+        return Err(error(format!(
+            "native startup {:?}: {}",
+            record.outcome,
+            record.failure.unwrap_or_default()
+        )));
+    }
+    Ok(())
+}
+
+pub fn project_seat(workspace: &Path, team: &str, id: &str) -> Result<Value, BackendError> {
+    let mut backend = Backend::open_readonly(workspace, team)?;
+    let seat = backend
+        .store
+        .seat(&SeatId::new(id)?)?
+        .ok_or(BackendError::Metadata)?;
+    let role = backend::read_role(&backend.binding, &seat.identity)?;
+    if role.provider != seat.provider {
+        return Err(BackendError::Metadata);
+    }
+    let alive = seat
+        .physical
+        .as_ref()
+        .is_some_and(|target| sample_process(&target.process) == ProcessState::Alive);
+    // Present only individually proven tools. A successful report_result
+    // never turns send_message/get_team_status into invented discoveries.
+    let mut observed = Vec::new();
+    let mut binding_source = None;
+    if super::registry::provider(seat.provider.as_str())?.uses_tool_roundtrips() {
+        let protocol = super::pump::protocol(&mut backend, &seat, &team_agent_contract::host::clock::RealClock::new())?;
+        if let team_agent_contract::contract::probe::ProbeOutcome::Observed(binding) = protocol.binding.outcome {
+            binding_source = Some(format!("{:?}", binding.source));
+            observed = binding.tools;
+        }
+    }
+    let tools: serde_json::Map<String, Value> = [
+        (team_agent_contract::contract::types::LogicalTool::SendMessage, "send_message"),
+        (team_agent_contract::contract::types::LogicalTool::ReportResult, "report_result"),
+        (team_agent_contract::contract::types::LogicalTool::GetTeamStatus, "get_team_status"),
+    ].into_iter().map(|(tool, name)| (name.into(), json!(if observed.contains(&tool) { "observed" } else { "unknown" }))).collect();
+    let binding_status = if observed.len() == 3 { "observed" } else if observed.is_empty() { "unverified" } else { "partial" };
+    let status = if seat.status == SeatStatus::Stopped {
+        "stopped"
+    } else if seat.status != SeatStatus::Unknown && alive {
+        "running"
+    } else {
+        "unknown"
+    };
+    Ok(
+        json!({"agent_id":id,"provider":seat.provider,"status":status,"model":role.model,"effort":role.effort,
+        "contract_prompt_sha256":team_agent_contract::host::digest_hex(role.prompt.sha256),
+        "runtime_family":"contract","contract_scope":seat.identity.scope,"contract_instance":seat.identity.instance,
+        "generation":seat.identity.generation,"owner_team_id":team,"team_key":team,
+        "session_id":seat.session.map(|session| session.native_session),
+        "native_endpoint":seat.endpoint,"native_pane":seat.pane,
+        "pane_id":null,"window":null,"session_name":null,
+        "mcp_binding":binding_status,"mcp_binding_source":binding_source,"mcp_tools":tools,
+        "bootstrap_used":seat.bootstrap_used}),
+    )
+}
+
+pub fn enqueue(
+    workspace: &Path,
+    state: &Value,
+    recipient: &str,
+    content: &str,
+    options: &crate::messaging::SendOptions,
+) -> Result<crate::messaging::DeliveryOutcome, crate::messaging::MessagingError> {
+    use crate::messaging::{DeliveryOutcome, DeliveryStatus, MessagingError};
+    let error = |error: String| MessagingError::Validation(error);
+    let team = crate::state::projection::team_state_key(state);
+    let mut backend = Backend::open(workspace, &team).map_err(|e| error(e.to_string()))?;
+    let request = OperatorSend {
+        recipient: SeatId::new(recipient).map_err(|e| error(e.to_string()))?,
+        content: content.into(),
+        task: options.task_id.as_ref().map(|task| task.as_str().into()),
+        message: options
+            .message_id
+            .clone()
+            .map(team_agent_contract::contract::types::MessageId::new)
+            .transpose()
+            .map_err(|e| error(e.to_string()))?,
+        mailbox: options.presentation.sink
+            == crate::messaging::presentation::PresentationSink::Casefile,
+    };
+    let sender = SeatId::new(options.sender.as_str()).map_err(|e| error(e.to_string()))?;
+    let receipt = backend
+        .store
+        .send_from_framework(&request, &sender)
+        .map_err(|e| error(e.to_string()))?;
+    // Queued is durable admission only. The coordinator consumes this outbox;
+    // CLI send never performs its own paste or repeats an uncertain attempt.
+    Ok(DeliveryOutcome {
+        ok: true,
+        status: if receipt.mailbox {
+            DeliveryStatus::StoredOnly
+        } else {
+            DeliveryStatus::Queued
+        },
+        message_status: crate::messaging::helpers::MessageStatusShadow(
+            if receipt.mailbox {
+                "stored_only"
+            } else {
+                "accepted"
+            }
+            .into(),
+        ),
+        message_id: Some(receipt.message.as_str().into()),
+        verification: Some(
+            json!({"runtime":"contract","task_id":receipt.task,
+            "target":receipt.target,"native_submission":"not_observed"})
+            .to_string(),
+        ),
+        stage: None,
+        reason: None,
+        channel: None,
+        ack_forced_off: false,
+        turn_verification: None,
+    })
+}
+
+pub fn stop_selected(workspace: &Path, state: &Value) -> Result<Vec<Value>, BackendError> {
+    let team = crate::state::projection::team_state_key(state);
+    let mut receipts = Vec::new();
+    if let Some(agents) = state.get("agents").and_then(Value::as_object) {
+        for (id, agent) in agents.iter().filter(|(_, agent)| is_contract(agent)) {
+            if is_paused_unstarted(agent) {
+                receipts.push(json!({"agent_id":id,"status":"paused","stopped":false}));
+                continue;
+            }
+            let backend = Backend::open(workspace, &team)?;
+            let seat = backend
+                .store
+                .seat(&SeatId::new(id)?)?
+                .ok_or(BackendError::Metadata)?;
+            if seat.status == SeatStatus::Stopped {
+                receipts.push(json!({"agent_id":id,"status":"already_stopped"}));
+                continue;
+            }
+            let _ = agent;
+            let receipt = backend::stop(workspace, &team, &SeatId::new(id)?)?;
+            if receipt.outcome != Outcome::Committed {
+                return Err(BackendError::Shutdown {
+                    operation: receipt.id,
+                    phase: receipt.phase,
+                    outcome: receipt.outcome,
+                    failure: receipt.failure,
+                });
+            }
+            receipts.push(json!({"agent_id":id,"status":"stopped","operation":receipt.id}));
+        }
+    }
+    Ok(receipts)
+}

package/crates/team-agent/src/contract_runtime/mcp.rs

@@ -0,0 +1,396 @@
+//! Owned native stdio entry. Invocation arguments identify an expected record;
+//! only actual executable/birth/parent and current instance checks authorize it.
+use std::fmt::Display;
+use std::io::Write;
+use std::path::Path;
+use std::time::{Duration, Instant};
+
+use serde_json::{json, Value};
+use team_agent_contract::contract::types::*;
+use team_agent_contract::host::process::{
+    capture_process, verify_native_ancestry, MAX_NATIVE_PARENT_HOPS,
+};
+use team_agent_contract::orchestration::{
+    mcp::*,
+    protocol::ConnectionRecord,
+    store::{ContractStore, SeatRecord, SeatStatus},
+    Error,
+};
+
+use super::backend::{Backend, BackendError};
+
+// Diagnostics are not protocol facts or admission. Never write them to stdout,
+// include request/argv/env bytes, or let a failed log write change the result.
+struct Diagnostics {
+    log: Option<crate::event_log::EventLog>,
+    fields: Value,
+}
+impl Diagnostics {
+    fn new() -> Self {
+        Self {
+            log: None,
+            fields: json!({
+                "pid": std::process::id(),
+                "entry_ppid": crate::platform::process::current_parent_pid(),
+            }),
+        }
+    }
+
+    fn bind_log(&mut self, workspace: &Path) {
+        let directory = crate::model::paths::logs_dir(workspace);
+        let path = directory.join("events.jsonl");
+        // Entry diagnostics must not create an unverified workspace, follow a
+        // redirected log path, or depend on successfully opening contract.db.
+        let regular_or_absent = std::fs::symlink_metadata(&path).map_or_else(
+            |error| error.kind() == std::io::ErrorKind::NotFound,
+            |metadata| metadata.is_file() && !metadata.file_type().is_symlink(),
+        );
+        if workspace.is_absolute()
+            && workspace.canonicalize().is_ok_and(|path| path == workspace)
+            && directory.canonicalize().is_ok_and(|path| path == directory)
+            && regular_or_absent
+        {
+            self.log = Some(crate::event_log::EventLog::new(workspace));
+        }
+    }
+
+    fn record(&self, stage: &str, outcome: &str, error: Option<&dyn Display>) -> Value {
+        let mut value = self.fields.clone();
+        value["event"] = json!("contract.mcp");
+        value["ts"] = json!(chrono::Utc::now().to_rfc3339());
+        value["stage"] = json!(stage);
+        value["outcome"] = json!(outcome);
+        if let Some(error) = error {
+            let text = crate::redaction::redact_external_text(&error.to_string());
+            value["error"] = json!(text.chars().take(256).collect::<String>());
+            value["error_truncated"] = json!(text.chars().count() > 256);
+        }
+        crate::redaction::redact_external_value(&value)
+    }
+
+    fn emit(&self, stage: &str, outcome: &str, error: Option<&dyn Display>) {
+        let value = self.record(stage, outcome, error);
+        write_diagnostic(self.log.as_ref(), &value, &mut std::io::stderr().lock());
+    }
+
+    fn step<T, E: Display>(
+        &self,
+        stage: &str,
+        action: impl FnOnce() -> Result<T, E>,
+    ) -> Result<T, E> {
+        self.emit(stage, "started", None);
+        let result = action();
+        self.emit(
+            stage,
+            if result.is_ok() { "ok" } else { "error" },
+            result.as_ref().err().map(|error| error as &dyn Display),
+        );
+        result
+    }
+}
+
+fn write_diagnostic(
+    log: Option<&crate::event_log::EventLog>,
+    value: &Value,
+    stderr: &mut impl Write,
+) {
+    if log.is_some_and(|log| log.write("contract.mcp", value.clone()).is_ok()) {
+        return;
+    }
+    if let Ok(mut bytes) = serde_json::to_vec(value) {
+        // Valid bounded JSON even if future diagnostic fields grow unexpectedly.
+        if bytes.len() > 8191 {
+            bytes = br#"{"event":"contract.mcp","stage":"diagnostic_size_limit"}"#.to_vec();
+        }
+        bytes.push(b'\n');
+        let _ = stderr.write_all(&bytes);
+    }
+}
+
+fn arguments(
+    args: &[String],
+) -> Result<(std::path::PathBuf, String, SeatId, InstanceId, Generation), BackendError> {
+    let mut values = std::collections::BTreeMap::new();
+    if !args.len().is_multiple_of(2) {
+        return Err(BackendError::Metadata);
+    }
+    for pair in args.chunks_exact(2) {
+        if !matches!(
+            pair[0].as_str(),
+            "--workspace" | "--team" | "--seat" | "--instance" | "--generation"
+        ) || values.insert(pair[0].as_str(), pair[1].as_str()).is_some()
+        {
+            return Err(BackendError::Metadata);
+        }
+    }
+    if values.len() != 5 {
+        return Err(BackendError::Metadata);
+    }
+    let get = |key| values.get(key).copied().ok_or(BackendError::Metadata);
+    Ok((
+        get("--workspace")?.into(),
+        get("--team")?.into(),
+        SeatId::new(get("--seat")?)?,
+        InstanceId::new(get("--instance")?)?,
+        Generation(
+            get("--generation")?
+                .parse()
+                .map_err(|_| BackendError::Metadata)?,
+        ),
+    ))
+}
+fn wait_target(store: &ContractStore, identity: &InstanceIdentity) -> Result<SeatRecord, Error> {
+    let deadline = Instant::now() + Duration::from_secs(30);
+    loop {
+        let seat = store.assert_current(identity)?;
+        if matches!(seat.status, SeatStatus::Stopped | SeatStatus::Unknown) {
+            return Err(Error::Fence);
+        }
+        if seat.physical.is_some() {
+            return Ok(seat);
+        }
+        if Instant::now() >= deadline {
+            return Err(Error::Host("native target publication timed out"));
+        }
+        std::thread::sleep(Duration::from_millis(25));
+    }
+}
+
+pub fn run(args: &[String]) -> Result<(), BackendError> {
+    let mut diagnostics = Diagnostics::new();
+    // This is the first action in the main.rs contract-mcp dispatch target.
+    // Arguments are not trusted as a log destination yet: stderr only.
+    diagnostics.emit("entry", "entered", None);
+    let result = run_observed(args, &mut diagnostics);
+    diagnostics.emit(
+        "exit",
+        if result.is_ok() { "ok" } else { "error" },
+        result.as_ref().err().map(|error| error as &dyn Display),
+    );
+    result
+}
+
+fn run_observed(args: &[String], diagnostics: &mut Diagnostics) -> Result<(), BackendError> {
+    let (workspace, team, seat, instance, generation) =
+        diagnostics.step("arguments", || arguments(args))?;
+    diagnostics.bind_log(&workspace);
+    diagnostics.fields["seat"] = json!(seat.as_str().chars().take(96).collect::<String>());
+    diagnostics.fields["instance"] = json!(instance.as_str().chars().take(96).collect::<String>());
+    diagnostics.fields["generation"] = json!(generation.0);
+    diagnostics.emit("entry", "arguments_validated", None);
+    let mut backend = diagnostics.step("backend_open", || Backend::open(&workspace, &team))?;
+    let identity = InstanceIdentity {
+        scope: backend.binding.scope.clone(),
+        seat,
+        instance,
+        generation,
+    };
+    diagnostics.fields["scope"] = json!(identity.scope.as_str());
+    let seat = diagnostics.step("target_wait", || wait_target(&backend.store, &identity))?;
+    let target = seat
+        .physical
+        .as_ref()
+        .ok_or(Error::Invalid("native target missing"))?;
+    diagnostics.fields["expected_native_pid"] = json!(target.process.identity.pid);
+    diagnostics.emit("target_published", "observed", None);
+    let process = diagnostics.step("process_capture", || {
+        capture_process(
+            std::process::id(),
+            &backend.binding.candidate,
+            backend.binding.candidate_sha256,
+            Duration::from_secs(10),
+        )
+    })?;
+    diagnostics.fields["captured_ppid"] = json!(process.parent);
+    diagnostics.fields["direct_parent_matches"] =
+        json!(process.parent == target.process.identity.pid);
+    diagnostics.fields["max_parent_hops"] = json!(MAX_NATIVE_PARENT_HOPS);
+    diagnostics.emit("parent_fence", "started", None);
+    let ancestry = verify_native_ancestry(&process, &target.process);
+    diagnostics.fields["parent_matches"] = json!(ancestry.is_ok());
+    if let Ok(chain) = &ancestry {
+        diagnostics.fields["ancestor_chain"] = json!(chain);
+    }
+    diagnostics.emit(
+        "parent_fence",
+        if ancestry.is_ok() { "ok" } else { "error" },
+        ancestry.as_ref().err().map(|error| error as &dyn Display),
+    );
+    ancestry?;
+    let connection = diagnostics
+        .step("connection_identity", || {
+            backend.store.propose_identity(&identity.seat)
+        })?
+        .instance;
+    let record = ConnectionRecord {
+        identity: identity.clone(),
+        connection: connection.clone(),
+        server_key: seat.server_key.clone(),
+        binding_key: seat.binding_key.clone(),
+        process,
+        native_process: target.process.clone(),
+        closed: false,
+    };
+    diagnostics.step("register_connection", || {
+        backend.store.register_connection(&record)
+    })?;
+    // Registration is not an initialize/tools-list/client-consumption fact.
+    // Those continue to be recorded only at the existing protocol boundaries.
+    let result = diagnostics.step("serve", || {
+        serve_with_diagnostics(
+            &mut backend.store,
+            |store, request| {
+                if verify_native_ancestry(&record.process, &record.native_process).is_err() {
+                    return Err(Error::Fence);
+                }
+                let current = store.assert_current(&identity)?;
+                if current.binding_key != record.binding_key
+                    || matches!(current.status, SeatStatus::Stopped | SeatStatus::Unknown)
+                    || current
+                        .physical
+                        .as_ref()
+                        .is_none_or(|target| target.process != record.native_process)
+                {
+                    return Err(Error::Fence);
+                }
+                let business =
+                    request.get("method").and_then(serde_json::Value::as_str) == Some("tools/call");
+                let mut task = String::new();
+                if business {
+                    // A native callback can race the physical receipt's DB commit. Wait
+                    // for that exact generation's submitted turn, never a queued row.
+                    let deadline = Instant::now() + Duration::from_secs(5);
+                    loop {
+                        match store.submitted_task(&identity) {
+                            Ok(Some(bound)) => {
+                                task = bound;
+                                break;
+                            }
+                            Ok(None) | Err(Error::Conflict) if Instant::now() < deadline => {
+                                std::thread::sleep(Duration::from_millis(20))
+                            }
+                            Ok(None) => return Err(Error::Invalid("no submitted native turn")),
+                            Err(error) => return Err(error),
+                        }
+                    }
+                }
+                if verify_native_ancestry(&record.process, &record.native_process).is_err() {
+                    return Err(Error::Fence);
+                }
+                Ok(CallContext {
+                    identity: identity.clone(),
+                    binding_key: record.binding_key.clone(),
+                    connection_id: connection.clone(),
+                    task_id: task,
+                })
+            },
+            std::io::stdin().lock(),
+            std::io::stdout().lock(),
+            |stage, error| {
+                diagnostics.emit(
+                    match stage {
+                        RequestRejectionStage::Context => "request_context",
+                        RequestRejectionStage::Handler => "request_handler",
+                    },
+                    "rejected",
+                    Some(error),
+                );
+            },
+        )
+    });
+    let closed = diagnostics.step("close_connection", || {
+        backend.store.close_connection(&identity, &connection)
+    });
+    result?;
+    closed?;
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn diagnostics_preserve_errors_and_distinguish_captured_and_expected_parent() {
+        let mut diagnostics = Diagnostics::new();
+        diagnostics.fields["captured_ppid"] = json!(202);
+        diagnostics.fields["expected_native_pid"] = json!(303);
+        diagnostics.fields["parent_matches"] = json!(false);
+        let result = diagnostics.step("parent_fence", || Err::<(), _>(Error::Fence));
+        assert_eq!(result, Err(Error::Fence));
+        let event = diagnostics.record("parent_fence", "error", Some(&Error::Fence));
+        assert_eq!(event["captured_ppid"], 202);
+        assert_eq!(event["expected_native_pid"], 303);
+        assert_eq!(event["parent_matches"], false);
+        assert_eq!(event["error"], Error::Fence.to_string());
+        assert!(event["entry_ppid"].is_number());
+    }
+
+    #[test]
+    fn rejected_requests_keep_the_actual_error_category_and_stage() {
+        let diagnostics = Diagnostics::new();
+        for (stage, error) in [
+            ("request_context", Error::Conflict),
+            ("request_context", Error::Fence),
+            ("request_context", Error::Database),
+            ("request_handler", Error::Invalid("argument type")),
+        ] {
+            let event = diagnostics.record(stage, "rejected", Some(&error));
+            assert_eq!(event["stage"], stage);
+            assert_eq!(event["outcome"], "rejected");
+            assert_eq!(event["error"], error.to_string());
+            assert!(event.get("request").is_none());
+            assert!(event.get("arguments").is_none());
+            let mut stderr = Vec::new();
+            write_diagnostic(None, &event, &mut stderr);
+            assert!(stderr.len() <= 8192);
+            assert_eq!(serde_json::from_slice::<Value>(&stderr).unwrap(), event);
+        }
+    }
+
+    #[test]
+    fn diagnostics_redact_and_bound_error_without_argument_or_environment_fields() {
+        let diagnostics = Diagnostics::new();
+        let error = format!("PASSWORD=do-not-log {}", "x".repeat(20_000));
+        let event = diagnostics.record("arguments", "error", Some(&error));
+        assert_eq!(event["error_truncated"], true);
+        assert!(!event.to_string().contains("do-not-log"));
+        for field in ["argv", "args", "env", "prompt", "request", "content"] {
+            assert!(event.get(field).is_none());
+        }
+        let mut stderr = Vec::new();
+        write_diagnostic(None, &event, &mut stderr);
+        assert!(stderr.len() <= 8192);
+        assert_eq!(serde_json::from_slice::<Value>(&stderr).unwrap(), event);
+    }
+
+    #[test]
+    fn diagnostic_sink_failures_do_not_change_execution_results() {
+        let log = crate::event_log::EventLog::at("/dev/null/contract-mcp-events".into());
+        let diagnostics = Diagnostics::new();
+        let event = diagnostics.record("backend_open", "error", Some(&Error::Fence));
+        let mut stderr = Vec::new();
+        write_diagnostic(Some(&log), &event, &mut stderr);
+        assert_eq!(serde_json::from_slice::<Value>(&stderr).unwrap(), event);
+        struct Broken;
+        impl Write for Broken {
+            fn write(&mut self, _: &[u8]) -> std::io::Result<usize> {
+                Err(std::io::ErrorKind::BrokenPipe.into())
+            }
+            fn flush(&mut self) -> std::io::Result<()> {
+                Err(std::io::ErrorKind::BrokenPipe.into())
+            }
+        }
+        write_diagnostic(Some(&log), &event, &mut Broken);
+        assert_eq!(diagnostics.step("fixture", || Ok::<_, Error>(17)), Ok(17));
+        stderr.clear();
+        write_diagnostic(
+            None,
+            &json!({"unexpected": "x".repeat(20_000)}),
+            &mut stderr,
+        );
+        let bounded: Value = serde_json::from_slice(&stderr).unwrap();
+        assert_eq!(bounded["stage"], "diagnostic_size_limit");
+        assert!(stderr.len() <= 8192);
+    }
+}