@team-agent/installer 0.5.59 → 0.5.61

package/crates/team-agent/src/messaging/tests/leader_inject_acceptance.rs

@@ -99,6 +99,141 @@ fn attached_leader_mailbox_is_rechecked_by_the_normal_delivery_tick() {
     assert!(case.events().contains("leader_receiver.mailbox_requeued"));
 }
 
+#[test]
+fn leader_submit_without_receipt_source_cannot_park_forever_without_a_completion_writer() {
+    let case = Case::new_without_rollout("missing-receipt-source");
+    let transport = RecordingTransport::new("");
+    let message_id = case.seed_message("missing receipt source canary");
+
+    let first = deliver_pending_message(
+        &case.workspace,
+        &case.store,
+        &transport,
+        &message_id,
+        &case.event_log,
+        &case.state,
+    )
+    .expect("verified leader transport submission");
+
+    assert_ne!(
+        case.message_status(&message_id),
+        "submitted_pending_acceptance",
+        "F4 acceptance-stall: a verified leader transport submit with no reachable \
+         receipt source must not enter submitted_pending_acceptance, because that \
+         protected state has no completion writer. The runtime may close the \
+         transport-acceptance fact or expose a provider-session receipt writer, \
+         but it must not report an indefinitely retryable fact-terminal. outcome={first:?}"
+    );
+    assert_eq!(
+        transport.inject_count(),
+        1,
+        "the acceptance repair must not obtain progress by physically injecting twice"
+    );
+
+    let _ = deliver_pending_message(
+        &case.workspace,
+        &case.store,
+        &transport,
+        &message_id,
+        &case.event_log,
+        &case.state,
+    );
+    assert_eq!(
+        transport.inject_count(),
+        1,
+        "a second coordinator observation must not replay the already-submitted leader message"
+    );
+}
+
+#[test]
+fn nonempty_missing_receipt_source_is_not_token_absent() {
+    assert_unavailable_rollout_converges(
+        "missing-rollout",
+        PathBuf::from("definitely-missing-leader-rollout.jsonl"),
+        false,
+    );
+}
+
+#[test]
+fn nonempty_unreadable_receipt_source_is_not_token_absent() {
+    assert_unavailable_rollout_converges(
+        "unreadable-rollout",
+        PathBuf::from("leader-rollout-is-a-directory"),
+        true,
+    );
+}
+
+fn assert_unavailable_rollout_converges(tag: &str, rollout: PathBuf, directory: bool) {
+    let case = Case::new_with_unavailable_rollout(tag, rollout, directory);
+    let transport = RecordingTransport::new("");
+    let message_id = case.seed_message("unavailable receipt source canary");
+
+    let first = deliver_pending_message(
+        &case.workspace,
+        &case.store,
+        &transport,
+        &message_id,
+        &case.event_log,
+        &case.state,
+    )
+    .expect("verified leader transport submission");
+
+    assert_eq!(
+        case.message_status(&message_id),
+        "injected_awaiting_receipt",
+        "F4 receipt observation must distinguish an unreadable nonempty rollout_path \
+         from a readable rollout that lacks the token. The former is \
+         receipt-source-unavailable and must converge to the typed parked state, \
+         not remain submitted_pending_acceptance. shape={tag} outcome={first:?}"
+    );
+    assert_eq!(
+        first.verification.as_deref(),
+        Some("leader_receipt_source_unavailable"),
+        "the outcome must expose read-unavailable rather than TokenAbsent; shape={tag}"
+    );
+    assert_eq!(transport.inject_count(), 1);
+
+    let _ = deliver_pending_message(
+        &case.workspace,
+        &case.store,
+        &transport,
+        &message_id,
+        &case.event_log,
+        &case.state,
+    );
+    assert_eq!(
+        transport.inject_count(),
+        1,
+        "read-unavailable convergence must not obtain progress by a second physical \
+         injection; shape={tag}"
+    );
+}
+
+#[test]
+fn worker_consumption_writer_remains_a_positive_control() {
+    let case = Case::new("worker-positive-control");
+    let message_id = case
+        .store
+        .create_message(
+            None,
+            "leader",
+            "worker",
+            "worker consume canary",
+            None,
+            false,
+            None,
+        )
+        .unwrap();
+
+    case.store.mark(&message_id, "consumed", None).unwrap();
+
+    assert_eq!(
+        case.message_status(&message_id),
+        "consumed",
+        "positive control: the independent worker consumption writer must remain reachable"
+    );
+}
+
 struct Case {
     workspace: PathBuf,
     rollout: PathBuf,
@@ -134,6 +269,58 @@ impl Case {
         }
     }
 
+    fn new_without_rollout(tag: &str) -> Self {
+        let workspace = tmp_ws(&format!("leader-inject-acceptance-{tag}"));
+        let rollout = workspace.join("absent-leader.jsonl");
+        let state = serde_json::json!({
+            "active_team_key": "acceptance-team",
+            "session_name": "team-acceptance",
+            "leader_receiver": {
+                "pane_id": "%leader",
+                "status": "attached",
+                "provider": "claude"
+            }
+        });
+        crate::state::persist::save_runtime_state(&workspace, &state).unwrap();
+        let store = MessageStore::open(&workspace).unwrap();
+        let event_log = EventLog::new(&workspace);
+        Self {
+            workspace,
+            rollout,
+            store,
+            event_log,
+            state,
+        }
+    }
+
+    fn new_with_unavailable_rollout(tag: &str, relative: PathBuf, directory: bool) -> Self {
+        let workspace = tmp_ws(&format!("leader-inject-acceptance-{tag}"));
+        let rollout = workspace.join(relative);
+        if directory {
+            std::fs::create_dir_all(&rollout).unwrap();
+        }
+        let state = serde_json::json!({
+            "active_team_key": "acceptance-team",
+            "session_name": "team-acceptance",
+            "leader_receiver": {
+                "pane_id": "%leader",
+                "status": "attached",
+                "provider": "claude",
+                "rollout_path": rollout,
+            }
+        });
+        crate::state::persist::save_runtime_state(&workspace, &state).unwrap();
+        let store = MessageStore::open(&workspace).unwrap();
+        let event_log = EventLog::new(&workspace);
+        Self {
+            workspace,
+            rollout,
+            store,
+            event_log,
+            state,
+        }
+    }
+
     fn seed_message(&self, content: &str) -> String {
         self.store
             .create_message(None, "worker", "leader", content, None, false, None)

package/crates/team-agent/src/messaging/tests/runtime.rs

@@ -2976,9 +2976,8 @@ fn gate054_attached_status_still_accepts_when_pane_is_live() {
     // Injection-case revision: transport submit success is NOT a provider
     // receipt, so the old `delivered` pin was a false-positive lock
     // (MUST-10: physical submit is the framework's fact; acceptance is the
-    // provider's). The un-refused path now parks the SAME row in
-    // submitted_pending_acceptance until a provider receipt or retry
-    // schedule advances it.
+    // provider's). The un-refused path now records the SAME row in the typed
+    // post-injection fact state until a provider receipt advances it.
     let ws = tmp_ws("gate054ok");
     let store = store_for(&ws);
     let log = EventLog::new(&ws);
@@ -3012,10 +3011,18 @@ fn gate054_attached_status_still_accepts_when_pane_is_live() {
         1,
         "gate054: exactly one physical inject must have happened (MUST-10 anchor)"
     );
+    let injected_awaiting_receipt = crate::db::message_store::MessageRowStatus::ALL
+        .iter()
+        .map(|status| status.as_str())
+        .find(|status| *status == "injected_awaiting_receipt")
+        .expect(
+            "gate054 signed reanchor: typed status directory must expose \
+             injected_awaiting_receipt",
+        );
     assert_eq!(
-        out.message_status.0, "submitted_pending_acceptance",
-        "gate054 (injection-case revision): a successful physical submit without a provider \
-         receipt must park as submitted_pending_acceptance, never claim delivered: {out:?}"
+        out.message_status.0, injected_awaiting_receipt,
+        "gate054 signed reanchor: a successful physical inject without a provider receipt \
+         must remain non-delivered as injected_awaiting_receipt, never claim delivered: {out:?}"
     );
 }
 

package/crates/team-agent/src/messaging/types.rs

@@ -53,6 +53,11 @@ pub enum DeliveryRefusal {
     TmuxTargetMissing,
     MessageAlreadyClaimed,
     LeaderNotAttached,
+    /// The recorded leader pane is live but belongs to another workspace.
+    /// Keep this typed cause distinct from an actually unattached leader so
+    /// the send surface can return the existing recovery action.
+    #[serde(rename = "PaneWorkspaceMismatch")]
+    PaneWorkspaceMismatch,
     NoCallerPane,
     TeamOwnerMismatch,
     Ambiguous,

package/crates/team-agent/src/messaging/watchers.rs

@@ -529,6 +529,11 @@ pub(crate) fn requeue_blocked_leader_messages(
                     "blocked_leader_unbound": counts.blocked_leader_unbound,
                     "queued_until_leader_attach": counts.queued_until_leader_attach,
                 },
+                "attach_window_failures": {
+                    "reason": "leader_not_attached",
+                    "count": counts.blocked_leader_unbound,
+                    "status": "requeued_pending_physical_retry",
+                },
             }),
         )?;
     }

package/crates/team-agent/src/model/mod.rs

@@ -18,6 +18,7 @@ pub mod ids;
 // cli/send.rs (positional adapter), mcp_server/tools.rs (owner-scoped
 // peer suggestions). Never a routing authority — advisory only.
 pub(crate) mod name_similarity;
+pub mod pane_authority_refusal;
 pub mod paths;
 pub mod permissions;
 pub mod routing;

package/crates/team-agent/src/model/pane_authority_refusal.rs

@@ -0,0 +1,358 @@
+//! Shared typed catalog for ambient tmux pane authority refusals.
+//!
+//! This module owns identities and payload shape only. Launchers and CLI
+//! presenters remain responsible for collecting facts and rendering them.
+
+use std::path::PathBuf;
+
+pub const REASON_FIELD: &str = "reason";
+pub const AVAILABILITY_FIELD: &str = "availability";
+pub const CAUSE_FIELD: &str = "cause";
+pub const ACTION_REQUIRED_FIELD: &str = "action_required";
+pub const HINT_ACTION_FIELD: &str = "hint_action";
+pub const ACTION_FIELD: &str = "action";
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum PaneAuthorityRefusalField {
+    RequestedWorkspace,
+    ObservedPaneId,
+    ObservedPaneWorkspace,
+    Endpoint,
+    CallerControllingTty,
+    ObservedPaneTty,
+}
+
+impl PaneAuthorityRefusalField {
+    pub const fn as_str(self) -> &'static str {
+        match self {
+            Self::RequestedWorkspace => "requested_workspace",
+            Self::ObservedPaneId => "observed_pane_id",
+            Self::ObservedPaneWorkspace => "observed_pane_workspace",
+            Self::Endpoint => "endpoint",
+            Self::CallerControllingTty => "caller_controlling_tty",
+            Self::ObservedPaneTty => "observed_pane_tty",
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum PaneAuthorityRefusalReason {
+    AmbientTmuxEndpointUnavailable,
+    AmbientPaneIdUnavailable,
+    AmbientPaneWorkspaceUnavailable,
+    CallerControllingTtyUnavailable,
+    ObservedPaneTtyUnavailable,
+    PaneTtyMismatch,
+    PaneWorkspaceMismatch,
+}
+
+impl PaneAuthorityRefusalReason {
+    pub const ALL: [Self; 7] = [
+        Self::AmbientTmuxEndpointUnavailable,
+        Self::AmbientPaneIdUnavailable,
+        Self::AmbientPaneWorkspaceUnavailable,
+        Self::CallerControllingTtyUnavailable,
+        Self::ObservedPaneTtyUnavailable,
+        Self::PaneTtyMismatch,
+        Self::PaneWorkspaceMismatch,
+    ];
+
+    pub const fn as_str(self) -> &'static str {
+        match self {
+            Self::AmbientTmuxEndpointUnavailable => "AmbientTmuxEndpointUnavailable",
+            Self::AmbientPaneIdUnavailable => "AmbientPaneIdUnavailable",
+            Self::AmbientPaneWorkspaceUnavailable => "AmbientPaneWorkspaceUnavailable",
+            Self::CallerControllingTtyUnavailable => "CallerControllingTtyUnavailable",
+            Self::ObservedPaneTtyUnavailable => "ObservedPaneTtyUnavailable",
+            Self::PaneTtyMismatch => "PaneTtyMismatch",
+            Self::PaneWorkspaceMismatch => "PaneWorkspaceMismatch",
+        }
+    }
+
+    pub const fn required_fact_fields(self) -> &'static [PaneAuthorityRefusalField] {
+        use PaneAuthorityRefusalField::{
+            CallerControllingTty, Endpoint, ObservedPaneId, ObservedPaneTty, ObservedPaneWorkspace,
+            RequestedWorkspace,
+        };
+
+        match self {
+            Self::AmbientTmuxEndpointUnavailable => &[RequestedWorkspace, Endpoint],
+            Self::AmbientPaneIdUnavailable => &[RequestedWorkspace, ObservedPaneId, Endpoint],
+            Self::AmbientPaneWorkspaceUnavailable => &[
+                RequestedWorkspace,
+                ObservedPaneId,
+                ObservedPaneWorkspace,
+                Endpoint,
+            ],
+            Self::CallerControllingTtyUnavailable => &[
+                RequestedWorkspace,
+                ObservedPaneId,
+                Endpoint,
+                CallerControllingTty,
+            ],
+            Self::ObservedPaneTtyUnavailable => &[
+                RequestedWorkspace,
+                ObservedPaneId,
+                Endpoint,
+                ObservedPaneTty,
+            ],
+            Self::PaneTtyMismatch => &[
+                RequestedWorkspace,
+                ObservedPaneId,
+                Endpoint,
+                CallerControllingTty,
+                ObservedPaneTty,
+            ],
+            Self::PaneWorkspaceMismatch => &[
+                RequestedWorkspace,
+                ObservedPaneId,
+                ObservedPaneWorkspace,
+                Endpoint,
+            ],
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum PaneAuthorityFactAvailability {
+    Unavailable,
+}
+
+impl PaneAuthorityFactAvailability {
+    pub const fn as_str(self) -> &'static str {
+        match self {
+            Self::Unavailable => "unavailable",
+        }
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct UnavailablePaneAuthorityFact<C> {
+    pub cause: C,
+}
+
+impl<C> UnavailablePaneAuthorityFact<C> {
+    pub const fn new(cause: C) -> Self {
+        Self { cause }
+    }
+
+    pub const fn availability(&self) -> PaneAuthorityFactAvailability {
+        PaneAuthorityFactAvailability::Unavailable
+    }
+}
+
+macro_rules! unavailable_causes {
+    ($name:ident { $($variant:ident => $wire:literal),+ $(,)? }) => {
+        #[derive(Clone, Copy, Debug, Eq, PartialEq)]
+        pub enum $name {
+            $($variant),+
+        }
+
+        impl $name {
+            pub const fn as_str(self) -> &'static str {
+                match self {
+                    $(Self::$variant => $wire),+
+                }
+            }
+        }
+    };
+}
+
+unavailable_causes!(AmbientTmuxEndpointUnavailableCause {
+    TmuxValueNotUnicode => "tmux_value_not_unicode",
+    TmuxTupleFieldCountInvalid => "tmux_tuple_field_count_invalid",
+    EndpointMissing => "endpoint_missing",
+    EndpointNotAbsolute => "endpoint_not_absolute",
+    ServerPidInvalid => "server_pid_invalid",
+    SessionIndexInvalid => "session_index_invalid",
+});
+
+unavailable_causes!(AmbientPaneIdUnavailableCause {
+    EnvironmentValueMissing => "environment_value_missing",
+    EnvironmentValueEmpty => "environment_value_empty",
+    EnvironmentValueNotUnicode => "environment_value_not_unicode",
+});
+
+unavailable_causes!(AmbientPaneWorkspaceUnavailableCause {
+    PaneQueryFailed => "pane_query_failed",
+    PaneNotFound => "pane_not_found",
+    CurrentPathMissing => "current_path_missing",
+});
+
+unavailable_causes!(CallerControllingTtyUnavailableCause {
+    NoControllingTty => "no_controlling_tty",
+    DeviceIdentityUnresolvable => "device_identity_unresolvable",
+    PlatformUnsupported => "platform_unsupported",
+});
+
+unavailable_causes!(ObservedPaneTtyUnavailableCause {
+    PaneTtyMissing => "pane_tty_missing",
+    PaneTtyUnresolvable => "pane_tty_unresolvable",
+    PaneTtyNotCharacterDevice => "pane_tty_not_character_device",
+});
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct AmbientTmuxEndpointUnavailableFacts {
+    pub requested_workspace: PathBuf,
+    pub endpoint: UnavailablePaneAuthorityFact<AmbientTmuxEndpointUnavailableCause>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct AmbientPaneIdUnavailableFacts {
+    pub requested_workspace: PathBuf,
+    pub observed_pane_id: UnavailablePaneAuthorityFact<AmbientPaneIdUnavailableCause>,
+    pub endpoint: String,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct AmbientPaneWorkspaceUnavailableFacts {
+    pub requested_workspace: PathBuf,
+    pub observed_pane_id: String,
+    pub observed_pane_workspace: UnavailablePaneAuthorityFact<AmbientPaneWorkspaceUnavailableCause>,
+    pub endpoint: String,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct CallerControllingTtyUnavailableFacts {
+    pub requested_workspace: PathBuf,
+    pub observed_pane_id: String,
+    pub endpoint: String,
+    pub caller_controlling_tty: UnavailablePaneAuthorityFact<CallerControllingTtyUnavailableCause>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ObservedPaneTtyUnavailableFacts {
+    pub requested_workspace: PathBuf,
+    pub observed_pane_id: String,
+    pub endpoint: String,
+    pub observed_pane_tty: UnavailablePaneAuthorityFact<ObservedPaneTtyUnavailableCause>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct PaneTtyMismatchFacts {
+    pub requested_workspace: PathBuf,
+    pub observed_pane_id: String,
+    pub endpoint: String,
+    pub caller_controlling_tty: u64,
+    pub observed_pane_tty: u64,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct PaneWorkspaceMismatchFacts {
+    pub requested_workspace: PathBuf,
+    pub observed_pane_id: String,
+    pub observed_pane_workspace: PathBuf,
+    pub endpoint: String,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum PaneAuthorityRefusalFacts {
+    AmbientTmuxEndpointUnavailable(AmbientTmuxEndpointUnavailableFacts),
+    AmbientPaneIdUnavailable(AmbientPaneIdUnavailableFacts),
+    AmbientPaneWorkspaceUnavailable(AmbientPaneWorkspaceUnavailableFacts),
+    CallerControllingTtyUnavailable(CallerControllingTtyUnavailableFacts),
+    ObservedPaneTtyUnavailable(ObservedPaneTtyUnavailableFacts),
+    PaneTtyMismatch(PaneTtyMismatchFacts),
+    PaneWorkspaceMismatch(PaneWorkspaceMismatchFacts),
+}
+
+impl PaneAuthorityRefusalFacts {
+    pub const fn reason(&self) -> PaneAuthorityRefusalReason {
+        match self {
+            Self::AmbientTmuxEndpointUnavailable(_) => {
+                PaneAuthorityRefusalReason::AmbientTmuxEndpointUnavailable
+            }
+            Self::AmbientPaneIdUnavailable(_) => {
+                PaneAuthorityRefusalReason::AmbientPaneIdUnavailable
+            }
+            Self::AmbientPaneWorkspaceUnavailable(_) => {
+                PaneAuthorityRefusalReason::AmbientPaneWorkspaceUnavailable
+            }
+            Self::CallerControllingTtyUnavailable(_) => {
+                PaneAuthorityRefusalReason::CallerControllingTtyUnavailable
+            }
+            Self::ObservedPaneTtyUnavailable(_) => {
+                PaneAuthorityRefusalReason::ObservedPaneTtyUnavailable
+            }
+            Self::PaneTtyMismatch(_) => PaneAuthorityRefusalReason::PaneTtyMismatch,
+            Self::PaneWorkspaceMismatch(_) => PaneAuthorityRefusalReason::PaneWorkspaceMismatch,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum PaneAuthorityRecoveryHint {
+    AttachLeader,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum PaneAuthorityRecoveryAction {
+    OpenTerminalOutsideCurrentTmuxPaneOrAttachFromMatchingPane,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct PaneAuthorityRecovery {
+    pub action_required: bool,
+    pub hint_action: PaneAuthorityRecoveryHint,
+    pub action: PaneAuthorityRecoveryAction,
+}
+
+impl PaneAuthorityRecovery {
+    pub const REQUIRED: Self = Self {
+        action_required: true,
+        hint_action: PaneAuthorityRecoveryHint::AttachLeader,
+        action:
+            PaneAuthorityRecoveryAction::OpenTerminalOutsideCurrentTmuxPaneOrAttachFromMatchingPane,
+    };
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct PaneAuthorityRefusal {
+    pub facts: PaneAuthorityRefusalFacts,
+    pub recovery: PaneAuthorityRecovery,
+}
+
+impl PaneAuthorityRefusal {
+    pub const fn new(facts: PaneAuthorityRefusalFacts) -> Self {
+        Self {
+            facts,
+            recovery: PaneAuthorityRecovery::REQUIRED,
+        }
+    }
+
+    pub const fn reason(&self) -> PaneAuthorityRefusalReason {
+        self.facts.reason()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{PaneAuthorityRefusalField as Field, PaneAuthorityRefusalReason as Reason};
+
+    #[test]
+    fn reason_catalog_is_closed_and_mismatch_requires_all_four_workspace_facts() {
+        assert_eq!(Reason::ALL.len(), 7);
+        assert_eq!(
+            Reason::PaneWorkspaceMismatch.required_fact_fields(),
+            &[
+                Field::RequestedWorkspace,
+                Field::ObservedPaneId,
+                Field::ObservedPaneWorkspace,
+                Field::Endpoint,
+            ]
+        );
+    }
+
+    #[test]
+    fn unavailable_reasons_require_the_fact_they_could_not_observe() {
+        assert!(Reason::AmbientTmuxEndpointUnavailable
+            .required_fact_fields()
+            .contains(&Field::Endpoint));
+        assert!(Reason::AmbientPaneIdUnavailable
+            .required_fact_fields()
+            .contains(&Field::ObservedPaneId));
+        assert!(Reason::AmbientPaneWorkspaceUnavailable
+            .required_fact_fields()
+            .contains(&Field::ObservedPaneWorkspace));
+    }
+}

package/crates/team-agent/src/model/spec.rs

@@ -400,6 +400,7 @@ fn check_agent(agent: &Yaml, path: &str, errors: &mut Vec<String>) {
         "preferred_for",
         "avoid_for",
         "output_contract",
+        "communication_mode",
         "paused",
         "auth_mode",
         "profile",
@@ -412,6 +413,21 @@ fn check_agent(agent: &Yaml, path: &str, errors: &mut Vec<String>) {
     if !agent.is_map() {
         return;
     }
+    if let Some(value) = agent.get("communication_mode") {
+        match value.as_str() {
+            Some(raw) if crate::communication_mode::CommunicationMode::parse(raw).is_none() => {
+                errors.push(format!(
+                    "{path}/communication_mode: unknown communication_mode '{raw}'"
+                ));
+            }
+            None => {
+                errors.push(format!(
+                    "{path}/communication_mode: unknown communication_mode"
+                ));
+            }
+            Some(_) => {}
+        }
+    }
     // 0.4.x provider effort MVP step 3: effort syntactic + semantic validation.
     if let Some(raw) = agent.get("effort").and_then(Yaml::as_str) {
         match crate::model::enums::ProviderEffort::parse(raw) {