@team-agent/installer 0.2.11 → 0.3.1

package/crates/team-agent/src/mcp_server/normalize.rs

@@ -0,0 +1,312 @@
+//! step 14a · mcp_server::normalize — string-alias regularization + result compaction.
+
+use serde_json::Value;
+
+use crate::model::enums::{ChangeKind, ResultStatus, RiskSeverity, TestStatus};
+use crate::model::ids::{AgentId, TaskId};
+
+use super::helpers::{items_from_value, normalize_token, text_field, text_of_value};
+use super::types::{
+    NormalizedArtifact, NormalizedChange, NormalizedNextAction, NormalizedReportEnvelope,
+    NormalizedRisk, NormalizedTest, ToolOk, ToolResult,
+};
+
+// ═══════════════════════════════════════════════════════════════════════════
+// NORMALIZE — string-alias regularization onto the step-2 value enums.
+// These are contract-callable: RED tests pass alias strings and assert the enum.
+// ═══════════════════════════════════════════════════════════════════════════
+
+/// `_normalize_result_status` (`normalize.py:106-123`): map ok/done/passed/… aliases
+/// onto [`ResultStatus`]; anything unrecognized → `Success`.
+pub fn normalize_result_status(value: Option<&str>) -> ResultStatus {
+    match normalize_token(value).as_str() {
+        "blocked" | "block" => ResultStatus::Blocked,
+        "failed" | "fail" | "error" => ResultStatus::Failed,
+        "partial" | "partially_done" => ResultStatus::Partial,
+        _ => ResultStatus::Success,
+    }
+}
+
+/// `_normalize_change_kind` (`normalize.py:145-177`): alias map + description-keyword
+/// inference fallback → [`ChangeKind`]; no match → `Modified`.
+pub fn normalize_change_kind(value: Option<&str>, description: &str) -> ChangeKind {
+    match normalize_token(value).as_str() {
+        "created" | "create" | "add" | "added" | "new" => ChangeKind::Created,
+        "deleted" | "delete" | "remove" | "removed" => ChangeKind::Deleted,
+        "observed" | "observe" | "inspected" | "inspect" => ChangeKind::Observed,
+        "modified" | "modify" | "updated" | "update" | "changed" | "change" | "edited" | "edit" => {
+            ChangeKind::Modified
+        }
+        _ => {
+            let desc = description.to_ascii_lowercase();
+            if desc.contains("created") || desc.contains("added") || desc.contains("new file") {
+                ChangeKind::Created
+            } else if desc.contains("removed") || desc.contains("deleted") {
+                ChangeKind::Deleted
+            } else if desc.contains("verified") || desc.contains("observed") || desc.contains("inspected") {
+                ChangeKind::Observed
+            } else {
+                ChangeKind::Modified
+            }
+        }
+    }
+}
+
+/// `_normalize_test_status` (`normalize.py:199-212`): alias map → [`TestStatus`];
+/// unknown → `NotRun`.
+pub fn normalize_test_status(value: Option<&str>) -> TestStatus {
+    match normalize_token(value).as_str() {
+        "passed" | "pass" | "ok" | "success" => TestStatus::Passed,
+        "failed" | "fail" | "error" => TestStatus::Failed,
+        "skipped" | "skip" => TestStatus::Skipped,
+        _ => TestStatus::NotRun,
+    }
+}
+
+/// `severity` regularization (`normalize.py:226-228`): out-of-set → [`RiskSeverity::Low`].
+pub fn normalize_risk_severity(value: Option<&str>) -> RiskSeverity {
+    match normalize_token(value).as_str() {
+        "medium" => RiskSeverity::Medium,
+        "high" => RiskSeverity::High,
+        _ => RiskSeverity::Low,
+    }
+}
+
+/// `_normalize_report_envelope` (`normalize.py:67-80`): the whole-envelope regularizer.
+/// Contracts assert the returned [`NormalizedReportEnvelope`] (status enum, fixed
+/// schema_version, `"manual"`/`"unknown"` fallbacks, normalized child lists).
+pub fn normalize_report_envelope(env: &Value) -> NormalizedReportEnvelope {
+    let summary = text_field(env, "summary").unwrap_or_else(|| "completed".to_string());
+    let task_id = text_field(env, "task_id").unwrap_or_else(|| "manual".to_string());
+    let agent_id = text_field(env, "agent_id").unwrap_or_else(|| "unknown".to_string());
+    NormalizedReportEnvelope {
+        schema_version: "result_envelope_v1".to_string(),
+        task_id: TaskId::new(task_id),
+        agent_id: AgentId::new(agent_id),
+        status: normalize_result_status(env.get("status").and_then(Value::as_str)),
+        summary: summary.clone(),
+        changes: normalize_changes(env.get("changes"), &summary),
+        tests: normalize_tests(env.get("tests")),
+        risks: normalize_risks(env.get("risks")),
+        artifacts: normalize_artifacts(env.get("artifacts")),
+        next_actions: normalize_next_actions(env.get("next_actions")),
+    }
+}
+
+/// `_compact_tool_result` (`normalize.py:6-64`): whitelist-key compaction of a
+/// delegate result. ok vs error use different key sets; `fanout_*` status preserves
+/// `deliveries`/`recipients`; `acknowledged_messages` → `acknowledged_count` (len).
+/// An empty ok-compaction yields `{"ok": true}`.
+pub fn compact_tool_result(result: &Value) -> ToolResult {
+    let is_error = result.get("ok").and_then(Value::as_bool) == Some(false);
+    let mut fields = serde_json::Map::new();
+    let keys: &[&str] = if is_error {
+        &[
+            "ok",
+            "status",
+            "reason",
+            "error",
+            "message_id",
+            "agent_id",
+            "new_agent_id",
+            "source_agent_id",
+            "role_file_sha",
+            "session_id",
+            "to",
+            "targets",
+            "delivered_count",
+            "failed_count",
+            "fallback_path",
+            "suggestion",
+        ]
+    } else {
+        &[
+            "ok",
+            "status",
+            "message_id",
+            "to",
+            "targets",
+            "delivered_count",
+            "failed_count",
+            "submitted",
+            "visible",
+            "queued",
+            "durably_stored",
+            "result_id",
+            "task_id",
+            "agent_id",
+            "new_agent_id",
+            "source_agent_id",
+            "role_file_sha",
+            "session_id",
+            "leader_notified",
+            "notification_message_id",
+            "notification_status",
+            "notification_channel",
+            "notification_event_id",
+        ]
+    };
+    for key in keys {
+        if let Some(value) = result.get(*key) {
+            fields.insert((*key).to_string(), value.clone());
+        }
+    }
+    if result
+        .get("status")
+        .and_then(Value::as_str)
+        .is_some_and(|s| s.starts_with("fanout_"))
+    {
+        for key in ["deliveries", "recipients"] {
+            if let Some(value) = result.get(key) {
+                fields.insert(key.to_string(), value.clone());
+            }
+        }
+    }
+    if !is_error && result.get("acknowledged_messages").is_some() {
+        let value = result.get("acknowledged_messages").unwrap_or(&Value::Null);
+        let count = value.as_array().map_or(0, Vec::len);
+        fields.insert("acknowledged_count".to_string(), Value::from(count));
+    }
+    if fields.is_empty() {
+        fields.insert("ok".to_string(), Value::Bool(true));
+    }
+    Ok(ToolOk { fields })
+}
+
+pub(crate) fn normalize_changes(value: Option<&Value>, envelope_summary: &str) -> Vec<NormalizedChange> {
+    items_from_value(value)
+        .iter()
+        .filter_map(|item| {
+            let obj = item.as_object()?;
+            let path = obj
+                .get("path")
+                .or_else(|| obj.get("file"))
+                .or_else(|| obj.get("filepath"))
+                .or_else(|| obj.get("filename"))
+                .and_then(text_of_value)?;
+            let description = obj
+                .get("description")
+                .or_else(|| obj.get("summary"))
+                .or_else(|| obj.get("detail"))
+                .or_else(|| obj.get("details"))
+                .or_else(|| obj.get("message"))
+                .and_then(text_of_value)
+                .unwrap_or_else(|| envelope_summary.to_string());
+            let kind_value = obj
+                .get("kind")
+                .or_else(|| obj.get("type"))
+                .or_else(|| obj.get("action"))
+                .and_then(Value::as_str);
+            Some(NormalizedChange {
+                path,
+                kind: normalize_change_kind(kind_value, &description),
+                description,
+            })
+        })
+        .collect()
+}
+
+pub(crate) fn normalize_tests(value: Option<&Value>) -> Vec<NormalizedTest> {
+    items_from_value(value)
+        .iter()
+        .filter_map(|item| match item {
+            Value::Object(obj) => {
+                let command = obj
+                    .get("command")
+                    .or_else(|| obj.get("cmd"))
+                    .or_else(|| obj.get("name"))
+                    .or_else(|| obj.get("test"))
+                    .and_then(text_of_value)?;
+                Some(NormalizedTest {
+                    command,
+                    status: normalize_test_status(obj.get("status").and_then(Value::as_str)),
+                    detail: obj
+                        .get("detail")
+                        .or_else(|| obj.get("output"))
+                        .or_else(|| obj.get("stdout"))
+                        .or_else(|| obj.get("stderr"))
+                        .or_else(|| obj.get("summary"))
+                        .or_else(|| obj.get("message"))
+                        .and_then(text_of_value),
+                })
+            }
+            scalar => Some(NormalizedTest {
+                command: text_of_value(scalar)?,
+                status: TestStatus::NotRun,
+                detail: None,
+            }),
+        })
+        .collect()
+}
+
+pub(crate) fn normalize_risks(value: Option<&Value>) -> Vec<NormalizedRisk> {
+    items_from_value(value)
+        .iter()
+        .filter_map(|item| match item {
+            Value::Object(obj) => Some(NormalizedRisk {
+                severity: normalize_risk_severity(
+                    obj.get("severity").or_else(|| obj.get("level")).and_then(Value::as_str),
+                ),
+                description: obj
+                    .get("description")
+                    .or_else(|| obj.get("summary"))
+                    .or_else(|| obj.get("detail"))
+                    .or_else(|| obj.get("message"))
+                    .and_then(text_of_value)?,
+            }),
+            scalar => Some(NormalizedRisk {
+                severity: RiskSeverity::Low,
+                description: text_of_value(scalar)?,
+            }),
+        })
+        .collect()
+}
+
+pub(crate) fn normalize_artifacts(value: Option<&Value>) -> Vec<NormalizedArtifact> {
+    items_from_value(value)
+        .iter()
+        .filter_map(|item| match item {
+            Value::Object(obj) => {
+                let path = obj
+                    .get("path")
+                    .or_else(|| obj.get("file"))
+                    .or_else(|| obj.get("filepath"))
+                    .or_else(|| obj.get("filename"))
+                    .and_then(text_of_value)?;
+                let description = obj
+                    .get("description")
+                    .or_else(|| obj.get("summary"))
+                    .or_else(|| obj.get("detail"))
+                    .and_then(text_of_value)
+                    .unwrap_or_else(|| path.clone());
+                Some(NormalizedArtifact { path, description })
+            }
+            scalar => {
+                let path = text_of_value(scalar)?;
+                Some(NormalizedArtifact {
+                    path: path.clone(),
+                    description: path,
+                })
+            }
+        })
+        .collect()
+}
+
+pub(crate) fn normalize_next_actions(value: Option<&Value>) -> Vec<NormalizedNextAction> {
+    items_from_value(value)
+        .iter()
+        .filter_map(|item| match item {
+            Value::Object(obj) => obj
+                .get("description")
+                .or_else(|| obj.get("summary"))
+                .or_else(|| obj.get("action"))
+                .or_else(|| obj.get("todo"))
+                .or_else(|| obj.get("message"))
+                .and_then(text_of_value)
+                .map(|description| NormalizedNextAction {
+                    description,
+                }),
+            scalar => text_of_value(scalar).map(|description| NormalizedNextAction { description }),
+        })
+        .collect()
+}

package/crates/team-agent/src/mcp_server/tests/golden.rs

@@ -0,0 +1,283 @@
+    #[test]
+    fn compact_ok_whitelist_is_exact_23_key_golden_set_and_order() {
+        let r = json!({
+            "ok": true, "status": "accepted", "message_id": "m1", "to": "alice",
+            "targets": ["a", "b"], "delivered_count": 2, "failed_count": 1, "submitted": true,
+            "visible": true, "queued": 3, "durably_stored": true, "result_id": "r1",
+            "task_id": "t1", "agent_id": "ag1", "new_agent_id": "ag2", "source_agent_id": "ag3",
+            "role_file_sha": "sha", "session_id": "s1", "leader_notified": true,
+            "notification_message_id": "nm", "notification_status": "sent",
+            "notification_channel": "ch", "notification_event_id": "ev",
+            // non-whitelist (golden DROPS these — Rust currently INVENTS the first three):
+            "delivery_pending": true, "poll_via": "x", "state_file": "/p", "secret": "z"
+        });
+        let v = serde_json::to_value(compact_tool_result(&r).expect("ok compaction")).unwrap();
+        assert_eq!(keys(&v), vec![
+            "ok", "status", "message_id", "to", "targets", "delivered_count", "failed_count",
+            "submitted", "visible", "queued", "durably_stored", "result_id", "task_id",
+            "agent_id", "new_agent_id", "source_agent_id", "role_file_sha", "session_id",
+            "leader_notified", "notification_message_id", "notification_status",
+            "notification_channel", "notification_event_id",
+        ]);
+        // The invented Rust keys must NOT appear (golden has no such whitelist entries).
+        assert!(v.get("delivery_pending").is_none(), "delivery_pending not in golden ok-whitelist");
+        assert!(v.get("poll_via").is_none(), "poll_via not in golden ok-whitelist");
+        assert!(v.get("state_file").is_none(), "state_file not in golden ok-whitelist");
+        // golden drops everything but ok/status when only the invented keys are present:
+        let only_extra = json!({"ok": true, "status": "accepted",
+            "delivery_pending": true, "poll_via": "x", "state_file": "/p"});
+        let v2 = serde_json::to_value(compact_tool_result(&only_extra).unwrap()).unwrap();
+        assert_eq!(s(&v2), r#"{"ok":true,"status":"accepted"}"#);
+    }
+
+    // ── #30/#43/#50 compact error-whitelist: EXACT 16-key golden list + order ───
+    // GOLDEN (probe_mcp_red.py ERR-FULL-KEYS): normalize.py:8-25 order, all 16 kept.
+    #[test]
+    fn compact_error_whitelist_is_exact_16_key_golden_set_and_order() {
+        let r = json!({
+            "ok": false, "status": "failed", "reason": "boom", "error": "boom detail",
+            "message_id": "m1", "agent_id": "ag1", "new_agent_id": "ag2", "source_agent_id": "ag3",
+            "role_file_sha": "sha", "session_id": "s1", "to": "alice", "targets": ["a"],
+            "delivered_count": 0, "failed_count": 2, "fallback_path": "/fb", "suggestion": "try x",
+            // not in error-whitelist → dropped:
+            "result_id": "r1", "extra": "drop"
+        });
+        let v = serde_json::to_value(compact_tool_result(&r).expect("error compaction")).unwrap();
+        assert_eq!(keys(&v), vec![
+            "ok", "status", "reason", "error", "message_id", "agent_id", "new_agent_id",
+            "source_agent_id", "role_file_sha", "session_id", "to", "targets",
+            "delivered_count", "failed_count", "fallback_path", "suggestion",
+        ]);
+        assert!(v.get("result_id").is_none(), "result_id not in golden error-whitelist");
+    }
+
+    // ── #52 acknowledged_count is OK-PATH ONLY (normalize.py:62 inside else) ────
+    // GOLDEN (probe_mcp_red.py ACK-ON-ERR): an ok:false result with acknowledged_messages
+    // → {"ok":false,"status":"x"} (NO acknowledged_count). Rust adds it unconditionally.
+    #[test]
+    fn compact_acknowledged_count_not_added_on_error_path() {
+        let r = json!({"ok": false, "status": "x", "acknowledged_messages": ["a", "b"]});
+        let v = serde_json::to_value(compact_tool_result(&r).expect("error compaction")).unwrap();
+        assert!(v.get("acknowledged_count").is_none(),
+            "acknowledged_count is added only on the ok branch (normalize.py:62)");
+        assert_eq!(s(&v), r#"{"ok":false,"status":"x"}"#);
+    }
+
+    // ── #34/#45/#58 normalize_change_kind: golden alias map + keyword set ───────
+    // GOLDEN (probe_mcp_red.py CK ...): verified/verify→modified (NOT observed!);
+    // inspected/inspect/observe→observed; edited/edit→modified; desc 'inspected'→observed.
+    #[test]
+    fn change_kind_golden_alias_and_keyword_set() {
+        // verified/verify are NOT in the golden alias map → fall to keyword inference.
+        // With empty desc, keyword scan finds no match → Modified (golden), NOT Observed.
+        assert_eq!(normalize_change_kind(Some("verified"), ""), ChangeKind::Modified);
+        assert_eq!(normalize_change_kind(Some("verify"), ""), ChangeKind::Modified);
+        // inspected/inspect ARE in the golden alias map → Observed.
+        assert_eq!(normalize_change_kind(Some("inspected"), ""), ChangeKind::Observed);
+        assert_eq!(normalize_change_kind(Some("inspect"), ""), ChangeKind::Observed);
+        assert_eq!(normalize_change_kind(Some("observe"), ""), ChangeKind::Observed);
+        // edited/edit→Modified.
+        assert_eq!(normalize_change_kind(Some("edited"), ""), ChangeKind::Modified);
+        assert_eq!(normalize_change_kind(Some("edit"), ""), ChangeKind::Modified);
+        // description keyword scan for observed includes 'inspected'.
+        assert_eq!(normalize_change_kind(None, "inspected it"), ChangeKind::Observed);
+    }
+
+    // ── #40 normalize_result_status: 'partiallydone' (no underscore) → Success ──
+    // GOLDEN (probe_mcp_red.py STATUS partiallydone): not in mapping/canonical set → success.
+    #[test]
+    fn result_status_partiallydone_no_underscore_is_success() {
+        assert_eq!(normalize_result_status(Some("partiallydone")), ResultStatus::Success);
+        assert_eq!(normalize_result_status(Some("PartiallyDone")), ResultStatus::Success);
+    }
+
+    // ── #35/#46/#53 normalize_changes: full alias set + empty-path SKIP ─────────
+    // GOLDEN (probe_mcp_red.py CHG ...): path={path,file,filepath,filename};
+    // kind={kind,type,action}; desc={description,summary,detail,details,message};
+    // no-path item is SKIPPED (not a phantom path:"").
+    #[test]
+    fn normalize_changes_full_aliases_and_skip_empty_path() {
+        // filepath alias honored; kind 'type-ignored' is not a real alias → keyword
+        // inference on desc 'fb' → Modified.
+        let v = normalize_changes(Some(&json!([{"filepath": "x.rs", "kind": "type-ignored"}])), "fb");
+        assert_eq!(v, vec![NormalizedChange {
+            path: "x.rs".to_string(), kind: ChangeKind::Modified, description: "fb".to_string()
+        }]);
+        // 'type' alias → kind resolution.
+        let v2 = normalize_changes(Some(&json!([{"path": "p", "type": "create"}])), "fb");
+        assert_eq!(v2[0].kind, ChangeKind::Created);
+        // filename + detail aliases.
+        let v3 = normalize_changes(Some(&json!([{"filename": "c.rs", "detail": "deet"}])), "fb");
+        assert_eq!(v3, vec![NormalizedChange {
+            path: "c.rs".to_string(), kind: ChangeKind::Modified, description: "deet".to_string()
+        }]);
+        // no path at all → SKIPPED (golden returns []).
+        assert!(normalize_changes(Some(&json!([{"kind": "created", "description": "d"}])), "fb").is_empty());
+    }
+
+    // ── #35/#46/#54 normalize_tests: full aliases + scalar coercion + skip ──────
+    // GOLDEN (probe_mcp_red.py TST ...): command={command,cmd,name,test};
+    // detail={detail,output,stdout,stderr,summary,message} (NO 'details');
+    // non-dict scalar (incl int) → {command:str(v),status:not_run}; no-command dict SKIPPED;
+    // a bare non-list scalar value is wrapped via _items.
+    #[test]
+    fn normalize_tests_full_aliases_scalar_coerce_and_skip() {
+        // name alias + output alias.
+        let v = normalize_tests(Some(&json!([{"name": "t", "output": "O"}])));
+        assert_eq!(v, vec![NormalizedTest {
+            command: "t".to_string(), status: TestStatus::NotRun, detail: Some("O".to_string())
+        }]);
+        // int scalar coerced to "123".
+        let vi = normalize_tests(Some(&json!([123])));
+        assert_eq!(vi, vec![NormalizedTest {
+            command: "123".to_string(), status: TestStatus::NotRun, detail: None
+        }]);
+        // dict with no command key → SKIPPED.
+        assert!(normalize_tests(Some(&json!([{"status": "pass"}]))).is_empty());
+        // non-list scalar value wrapped (_items): "x" → one test.
+        let vw = normalize_tests(Some(&json!("x")));
+        assert_eq!(vw, vec![NormalizedTest {
+            command: "x".to_string(), status: TestStatus::NotRun, detail: None
+        }]);
+    }
+
+    // ── #35/#46/#55 normalize_risks: aliases + 'level' + scalar coerce + skip ───
+    // GOLDEN (probe_mcp_red.py RISK ...): desc={description,summary,detail,message};
+    // severity={severity,level}; int scalar→{severity:low,description:str(v)};
+    // no-description dict SKIPPED.
+    #[test]
+    fn normalize_risks_level_alias_scalar_coerce_and_skip() {
+        // 'detail' description alias + 'level' severity alias (HIGH → high).
+        let v = normalize_risks(Some(&json!([{"detail": "risky", "level": "HIGH"}])));
+        assert_eq!(v, vec![NormalizedRisk {
+            severity: RiskSeverity::High, description: "risky".to_string()
+        }]);
+        // int scalar coerced.
+        let vi = normalize_risks(Some(&json!([5])));
+        assert_eq!(vi, vec![NormalizedRisk {
+            severity: RiskSeverity::Low, description: "5".to_string()
+        }]);
+        // dict with no description → SKIPPED.
+        assert!(normalize_risks(Some(&json!([{"severity": "high"}]))).is_empty());
+    }
+
+    // ── #35/#46/#56 normalize_artifacts: aliases + scalar + skip ────────────────
+    // GOLDEN (probe_mcp_red.py ART ...): path={path,file,filepath,filename};
+    // desc={description,summary,detail} (default=path); no-path dict SKIPPED.
+    #[test]
+    fn normalize_artifacts_full_aliases_and_skip() {
+        // 'file' path alias + 'detail' description alias.
+        let v = normalize_artifacts(Some(&json!([{"file": "a.bin", "detail": "art"}])));
+        assert_eq!(v, vec![NormalizedArtifact {
+            path: "a.bin".to_string(), description: "art".to_string()
+        }]);
+        // dict with no path → SKIPPED.
+        assert!(normalize_artifacts(Some(&json!([{"description": "d"}]))).is_empty());
+    }
+
+    // ── #35/#46/#57 normalize_next_actions: action/todo/message aliases ─────────
+    // GOLDEN (probe_mcp_red.py NA ...): dict desc={description,summary,action,todo,message}.
+    #[test]
+    fn normalize_next_actions_action_todo_message_aliases() {
+        let v = normalize_next_actions(Some(&json!([
+            {"action": "a"}, {"todo": "t"}, {"message": "m"}
+        ])));
+        assert_eq!(v, vec![
+            NormalizedNextAction { description: "a".to_string() },
+            NormalizedNextAction { description: "t".to_string() },
+            NormalizedNextAction { description: "m".to_string() },
+        ]);
+    }
+
+    // ── #41 text_field: stringify non-string scalars (Python str()) ─────────────
+    // GOLDEN (probe_mcp_red.py ENV-NUMERIC): numeric task_id/agent_id/summary
+    // stringify to "123"/"456"/"42" (NOT the manual/unknown/completed fallbacks).
+    #[test]
+    fn report_envelope_stringifies_numeric_scalar_fields() {
+        let env = normalize_report_envelope(&json!({"task_id": 123, "agent_id": 456, "summary": 42}));
+        assert_eq!(env.task_id, TaskId::new("123"));
+        assert_eq!(env.agent_id, AgentId::new("456"));
+        assert_eq!(env.summary, "42");
+    }
+
+    // ── #28 handle_mcp initialize result KEY ORDER (server.py:55-59) ────────────
+    // GOLDEN (probe_init evidence): protocolVersion, capabilities, serverInfo.
+    // Rust currently emits protocolVersion, serverInfo, capabilities.
+    #[test]
+    fn handle_mcp_initialize_result_key_order_is_golden() {
+        let tools = TeamOrchestratorTools::with_identity(Path::new("/tmp/ws"), None, None);
+        let resp = handle_mcp(&tools, &json!({
+            "jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {"protocolVersion": "X"}
+        })).unwrap().expect("initialize frame");
+        let result = resp.result.unwrap();
+        assert_eq!(keys(&result), vec!["protocolVersion", "capabilities", "serverInfo"]);
+    }
+
+    // ── #31 tools/call text field: json.dumps DEFAULT separators (spaces) ───────
+    // GOLDEN (probe_mcp_red.py DUMPS-DEFAULT): text has a space after ':' and ','.
+    // Rust serde_json::to_string is compact (no spaces).
+    #[test]
+    fn tool_call_text_field_uses_json_dumps_default_spacing() {
+        let tools = TeamOrchestratorTools::with_identity(Path::new("/tmp/ws"), None, None);
+        let resp = handle_mcp(&tools, &json!({
+            "jsonrpc": "2.0", "id": 9, "method": "tools/call",
+            "params": {"name": "nope", "arguments": {}}
+        })).unwrap().unwrap();
+        let text = resp.result.unwrap()["content"][0]["text"].as_str().unwrap().to_string();
+        // The raw bytes are compared by MCP clients: golden has ": " and ", ".
+        assert!(text.contains(r#""ok": false"#), "golden json.dumps puts a space after ':'");
+        assert!(text.contains(r#""reason": "unknown_tool""#), "golden has space after ':' and ','");
+        assert!(text.starts_with(r#"{"ok": false, "reason": "unknown_tool""#),
+            "byte-stable golden prefix; got: {text}");
+    }
+
+    // ── #33/#39 dispatch: empty/missing tool → 'unknown tool None'; method fallback;
+    //    quote tool → Python repr double-quote switch ───────────────────────────
+    // GOLDEN (probe_dispatch_red.py): empty/missing tool message == "unknown tool None"
+    // (Python repr of None, not ''); method fallback resolves the tool name; a tool
+    // name containing a single quote reprs with DOUBLE quotes.
+    #[test]
+    fn dispatch_empty_and_missing_tool_message_is_unknown_tool_none() {
+        let tools = TeamOrchestratorTools::with_identity(Path::new("/tmp/ws"), None, None);
+        // empty-string tool is falsy in Python → falls through to method (None).
+        let e1 = dispatch(&tools, &json!({"tool": "", "arguments": {}})).expect_err("empty tool ⇒ Err");
+        assert_eq!(e1.message, "unknown tool None");
+        // no tool, no method at all.
+        let e2 = dispatch(&tools, &json!({"arguments": {}})).expect_err("missing tool ⇒ Err");
+        assert_eq!(e2.message, "unknown tool None");
+    }
+
+    #[test]
+    fn dispatch_falls_back_to_method_key_for_tool_name() {
+        // tool absent, method present and unknown → 'unknown tool 'nope'' (the method
+        // value, not 'unknown tool None'). Rust currently only falls back to 'name'.
+        let tools = TeamOrchestratorTools::with_identity(Path::new("/tmp/ws"), None, None);
+        let e = dispatch(&tools, &json!({"method": "nope", "params": {}})).expect_err("unknown ⇒ Err");
+        assert_eq!(e.message, "unknown tool 'nope'");
+    }
+
+    #[test]
+    fn dispatch_unknown_tool_with_quote_uses_python_repr_double_quotes() {
+        // GOLDEN QUOTE-TOOL: repr("a'b") switches to double quotes → unknown tool "a'b".
+        let tools = TeamOrchestratorTools::with_identity(Path::new("/tmp/ws"), None, None);
+        let e = dispatch(&tools, &json!({"tool": "a'b", "arguments": {}})).expect_err("unknown ⇒ Err");
+        assert_eq!(e.message, "unknown tool \"a'b\"");
+    }
+
+    // ── #37 rpc id echoed VERBATIM: float 1.5 and bigint beyond i64 ─────────────
+    // GOLDEN (probe_rpcid_red.py): id 1.5 → echoed 1.5; 99999999999999999999 → verbatim.
+    // Rust collapses both to null (RpcId has only Int(i64)/Str/Null).
+    #[test]
+    fn rpc_id_float_echoed_verbatim() {
+        let tools = TeamOrchestratorTools::with_identity(Path::new("/tmp/ws"), None, None);
+        let resp = handle_mcp(&tools, &json!({
+            "jsonrpc": "2.0", "id": 1.5, "method": "initialize", "params": {}
+        })).unwrap().unwrap();
+        let v = serde_json::to_value(&resp).unwrap();
+        assert_eq!(v["id"], json!(1.5), "float id echoed verbatim, not null");
+    }
+
+    // ── #51 dispatch_tool(SendMessage) WorkerAccepted returned VERBATIM ─────────
+    // GOLDEN (probe_sendoutcome evidence + tools.py:176-183): worker-accepted dict is
+    // returned DIRECTLY: keys [status, delivery_pending, poll_via, message_id]. Rust
+    // dispatch_tool re-runs compact_tool_result, dropping delivery_pending/poll_via.