@team-agent/installer 0.3.1 → 0.3.3

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

@@ -86,18 +86,21 @@ pub use leader_receiver::{
     claim_leader_receiver, mirror_peer_message_to_leader, send_to_leader_receiver,
 };
 pub use peers::allow_peer_talk;
-pub use results::{collect, collect_results_and_notify_watchers, report_result};
+pub use results::{
+    collect, collect_for_team, collect_results_and_notify_watchers, report_result,
+    report_result_for_owner_team,
+};
 pub use scheduler::{detect_stuck_agents, fire_due_scheduled_events, stuck_cancel, stuck_list};
 pub use selftest::{evaluate_idle_behavior, run_comms_selftest, CommsSelftestDriver};
 pub use send::{apply_worker_sender_bypass, send_message, session_drift_refusal, MessageTarget, SendOptions};
 pub use trust::{attempt_trust_auto_answer, TrustAnswerOutcome};
 pub use types::{
     ActivityStatus, AgentActivity, AlertSnapshot, AlertSuppression, AlertType, CheckEvidence,
-    CheckKind, CheckStatus, DeliveryOutcome, DeliveryRefusal, DeliveryStage, DeliveryStatus,
-    IdleEvaluation, LeaderNotificationKey, LeaderReceiver, PaneWidthQuery, ProviderSdkCalls,
-    ReceiverMode, ScheduledKind, SelftestCheck, SelftestReport, SendEventPayload, TrustRetryPayload,
-    WatcherNotice, RESULT_DELIVERY_MAX_ATTEMPTS, SEND_RETRY_MAX_ATTEMPTS, TRUST_RETRY_BACKOFF_SECONDS,
-    TRUST_RETRY_MAX_ATTEMPTS,
+    CheckKind, CheckStatus, ContractSuiteCheck, DeliveryOutcome, DeliveryRefusal, DeliveryStage,
+    DeliveryStatus, IdleEvaluation, LeaderNotificationKey, LeaderReceiver, PaneWidthQuery,
+    ProviderSdkCalls, ReceiverMode, ScheduledKind, SelftestCheck, SelftestReport, SendEventPayload,
+    TrustRetryPayload, WatcherNotice, RESULT_DELIVERY_MAX_ATTEMPTS, SEND_RETRY_MAX_ATTEMPTS,
+    TRUST_RETRY_BACKOFF_SECONDS, TRUST_RETRY_MAX_ATTEMPTS,
 };
 pub use watchers::{
     delivered_result_message, format_result_watcher_notification, notify_result_watchers,

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

@@ -6,10 +6,12 @@ use rusqlite::params;
 
 use crate::event_log::EventLog;
 use crate::message_store::MessageStore;
+use crate::transport::{InjectPayload, Key, PaneId, Target, Transport};
 
 use super::helpers::{next_result_id, required_str, validate_result_envelope};
 use super::types::SEND_RETRY_MAX_ATTEMPTS;
 use crate::model::ids::TaskId;
+use crate::state::projection::OwnerTeamResolution;
 use super::watchers::retry_result_deliveries;
 use super::MessagingError;
 
@@ -19,26 +21,65 @@ pub fn collect(
     workspace: &Path,
     result_file: Option<&Path>,
     ensure_coordinator: bool,
+) -> Result<serde_json::Value, MessagingError> {
+    collect_scoped(workspace, result_file, ensure_coordinator, None)
+}
+
+pub fn collect_for_team(
+    workspace: &Path,
+    result_file: Option<&Path>,
+    ensure_coordinator: bool,
+    owner_team_id: Option<&str>,
+) -> Result<serde_json::Value, MessagingError> {
+    collect_scoped(workspace, result_file, ensure_coordinator, owner_team_id)
+}
+
+fn collect_scoped(
+    workspace: &Path,
+    result_file: Option<&Path>,
+    ensure_coordinator: bool,
+    owner_team_id: Option<&str>,
 ) -> Result<serde_json::Value, MessagingError> {
     let _ = ensure_coordinator;
     let paths = collect_paths(workspace)?;
-    let spec_path = paths.spec_workspace.join("team.spec.yaml");
+    let log = EventLog::new(&paths.run_workspace);
+    let resolved_owner_team_id = match owner_team_id.filter(|team| !team.is_empty()) {
+        Some(team) => Some(resolve_owner_team_for_read(&paths.run_workspace, team, Some(&log))?),
+        None => None,
+    };
+    let owner_team_id = resolved_owner_team_id.as_deref();
+    let mut state = match owner_team_id {
+        Some(team) => crate::state::projection::select_runtime_state(&paths.run_workspace, Some(team))?,
+        None => crate::state::persist::load_runtime_state(&paths.run_workspace)?,
+    };
+    let spec_workspace = owner_team_id
+        .and_then(|_| state_spec_workspace_from_value(&state))
+        .unwrap_or_else(|| paths.spec_workspace.clone());
+    let spec_path = spec_workspace.join("team.spec.yaml");
     if !spec_path.exists() {
         return Err(MessagingError::Validation(format!("Cannot read {}", spec_path.display())));
     }
     let store = MessageStore::open(&paths.run_workspace)?;
     let conn = crate::db::schema::open_db(store.db_path())?;
     if let Some(path) = result_file {
-        ingest_result_file(&conn, path)?;
+        ingest_result_file(&conn, path, owner_team_id)?;
     }
-    let mut stmt = conn.prepare(
-        "select result_id, task_id, agent_id, envelope, status, created_at
-         from results
-         where status not in ('collected', 'invalid')
-         order by created_at, result_id",
-    )?;
-    let rows = stmt
-        .query_map([], |row| {
+    let sql = match owner_team_id {
+        Some(_) => {
+            "select result_id, task_id, agent_id, envelope, status, created_at
+             from results
+             where status not in ('collected', 'invalid') and owner_team_id = ?1
+             order by created_at, result_id"
+        }
+        None => {
+            "select result_id, task_id, agent_id, envelope, status, created_at
+             from results
+             where status not in ('collected', 'invalid')
+             order by created_at, result_id"
+        }
+    };
+    let mut stmt = conn.prepare(sql)?;
+    let row_mapper = |row: &rusqlite::Row<'_>| {
             Ok(StoredResult {
                 result_id: row.get(0)?,
                 task_id: row.get(1)?,
@@ -47,20 +88,24 @@ pub fn collect(
                 status: row.get(4)?,
                 created_at: row.get(5)?,
             })
-        })?
+        };
+    let rows = match owner_team_id {
+        Some(team) => stmt.query_map(params![team], row_mapper),
+        None => stmt.query_map([], row_mapper),
+    }?
         .collect::<Result<Vec<_>, _>>()?;
     drop(stmt);
 
-    let mut state = crate::state::persist::load_runtime_state(&paths.run_workspace)?;
     let mut collected = Vec::new();
     let mut collected_results = Vec::new();
     let mut invalid_results = Vec::new();
+    let mut fatal_invalid_results = 0usize;
     let mut state_dirty = false;
-    let log = EventLog::new(&paths.run_workspace);
     for row in rows {
         let envelope: serde_json::Value = match serde_json::from_str(&row.envelope) {
             Ok(envelope) => envelope,
             Err(error) => {
+                fatal_invalid_results = fatal_invalid_results.saturating_add(1);
                 record_invalid_result(
                     &conn,
                     &mut invalid_results,
@@ -72,6 +117,7 @@ pub fn collect(
             }
         };
         if let Err(error) = validate_result_envelope(&envelope) {
+            fatal_invalid_results = fatal_invalid_results.saturating_add(1);
             record_invalid_result(
                 &conn,
                 &mut invalid_results,
@@ -83,9 +129,12 @@ pub fn collect(
         }
         let scope = if task_exists(&state, &row.task_id) {
             "task"
-        } else if is_message_scoped_result(&conn, &row.task_id, &row.agent_id)? {
+        } else if is_message_scoped_result(&conn, &row.task_id, &row.agent_id, owner_team_id)? {
             "message"
         } else {
+            if result_file.is_some() || row.task_id != "manual" {
+                fatal_invalid_results = fatal_invalid_results.saturating_add(1);
+            }
             record_invalid_result(
                 &conn,
                 &mut invalid_results,
@@ -95,10 +144,20 @@ pub fn collect(
             )?;
             continue;
         };
-        conn.execute(
-            "update results set status = 'collected' where result_id = ?1",
-            params![row.result_id.as_str()],
-        )?;
+        match owner_team_id {
+            Some(team) => {
+                conn.execute(
+                    "update results set status = 'collected' where result_id = ?1 and owner_team_id = ?2",
+                    params![row.result_id.as_str(), team],
+                )?;
+            }
+            None => {
+                conn.execute(
+                    "update results set status = 'collected' where result_id = ?1",
+                    params![row.result_id.as_str()],
+                )?;
+            }
+        }
         if scope == "task" {
             mark_task_done(&mut state, &row.task_id, &row.result_id);
             state_dirty = true;
@@ -129,17 +188,21 @@ pub fn collect(
         collected_results.push(summary);
     }
     if state_dirty {
-        crate::state::persist::save_runtime_state(&paths.run_workspace, &state)?;
+        if owner_team_id.is_some() {
+            crate::state::projection::save_team_scoped_state(&paths.run_workspace, &state)?;
+        } else {
+            crate::state::persist::save_runtime_state(&paths.run_workspace, &state)?;
+        }
     }
-    let counts = result_counts(&conn)?;
+    let counts = result_counts(&conn, owner_team_id)?;
     Ok(serde_json::json!({
-        "ok": invalid_results.is_empty(),
+        "ok": fatal_invalid_results == 0,
         "collected": collected,
         "collected_results": collected_results,
         "delivered_messages": [],
         "invalid_results": invalid_results,
         "results": counts,
-        "state_file": paths.spec_workspace.join("team_state.md").to_string_lossy().to_string(),
+        "state_file": spec_workspace.join("team_state.md").to_string_lossy().to_string(),
         "coordinator": {
             "ok": false,
             "status": "not_required",
@@ -147,12 +210,48 @@ pub fn collect(
     }))
 }
 
+fn resolve_owner_team_for_read(
+    workspace: &Path,
+    requested: &str,
+    event_log: Option<&EventLog>,
+) -> Result<String, MessagingError> {
+    let state = crate::state::persist::load_runtime_state(workspace)?;
+    match crate::state::projection::resolve_owner_team_id(&state, requested) {
+        OwnerTeamResolution::Canonical(canonical) => Ok(canonical),
+        OwnerTeamResolution::LegacyAlias { requested, canonical } => {
+            crate::messaging::delivery::normalize_owner_team_id_rows(
+                workspace,
+                &requested,
+                &canonical,
+                None,
+                event_log,
+            )?;
+            Ok(canonical)
+        }
+        OwnerTeamResolution::Unresolved { requested } => {
+            Err(MessagingError::Routing(format!("owner_team_unresolved: {requested}")))
+        }
+        OwnerTeamResolution::Ambiguous { requested, matches } => {
+            Err(MessagingError::Routing(format!(
+                "owner_team_ambiguous: {requested} matches {}",
+                matches.join(",")
+            )))
+        }
+    }
+}
+
 struct CollectPaths {
     run_workspace: PathBuf,
     spec_workspace: PathBuf,
 }
 
 fn collect_paths(workspace: &Path) -> Result<CollectPaths, MessagingError> {
+    if collect_input_has_no_local_team_context(workspace) {
+        return Ok(CollectPaths {
+            run_workspace: workspace.to_path_buf(),
+            spec_workspace: workspace.to_path_buf(),
+        });
+    }
     let run_workspace = crate::model::paths::canonical_run_workspace(workspace)
         .map_err(|e| MessagingError::Routing(e.to_string()))?;
     let spec_workspace = if workspace.join("team.spec.yaml").exists() {
@@ -168,8 +267,24 @@ fn collect_paths(workspace: &Path) -> Result<CollectPaths, MessagingError> {
     })
 }
 
+fn collect_input_has_no_local_team_context(workspace: &Path) -> bool {
+    !workspace.join("team.spec.yaml").exists()
+        && !workspace.join(".team").exists()
+        && !crate::state::persist::runtime_state_path(workspace).exists()
+        && workspace.file_name().and_then(|s| s.to_str()) != Some(".team")
+        && workspace
+            .parent()
+            .and_then(|p| p.file_name())
+            .and_then(|s| s.to_str())
+            != Some(".team")
+}
+
 fn state_spec_workspace(run_workspace: &Path) -> Option<PathBuf> {
     let state = crate::state::persist::load_runtime_state(run_workspace).ok()?;
+    state_spec_workspace_from_value(&state)
+}
+
+fn state_spec_workspace_from_value(state: &serde_json::Value) -> Option<PathBuf> {
     if let Some(spec_path) = state.get("spec_path").and_then(serde_json::Value::as_str) {
         return PathBuf::from(spec_path).parent().map(Path::to_path_buf);
     }
@@ -200,7 +315,11 @@ fn record_invalid_result(
     Ok(())
 }
 
-fn ingest_result_file(conn: &rusqlite::Connection, path: &Path) -> Result<(), MessagingError> {
+fn ingest_result_file(
+    conn: &rusqlite::Connection,
+    path: &Path,
+    owner_team_id: Option<&str>,
+) -> Result<(), MessagingError> {
     let raw = std::fs::read_to_string(path)?;
     let mut envelope: serde_json::Value = serde_json::from_str(&raw)?;
     validate_result_envelope(&envelope)?;
@@ -226,7 +345,7 @@ fn ingest_result_file(conn: &rusqlite::Connection, path: &Path) -> Result<(), Me
         agent_id,
         &envelope.to_string(),
         status,
-        None,
+        owner_team_id,
     )?;
     Ok(())
 }
@@ -273,39 +392,55 @@ fn is_message_scoped_result(
     conn: &rusqlite::Connection,
     task_id: &str,
     agent_id: &str,
+    owner_team_id: Option<&str>,
 ) -> Result<bool, MessagingError> {
     if !task_id.starts_with("msg_") {
         return Ok(false);
     }
-    let count: i64 = conn.query_row(
-        "select count(*) from messages where message_id = ?1 and recipient = ?2",
-        params![task_id, agent_id],
-        |row| row.get(0),
-    )?;
+    let count: i64 = match owner_team_id {
+        Some(team) => conn.query_row(
+            "select count(*) from messages where message_id = ?1 and recipient = ?2 and owner_team_id = ?3",
+            params![task_id, agent_id, team],
+            |row| row.get(0),
+        )?,
+        None => conn.query_row(
+            "select count(*) from messages where message_id = ?1 and recipient = ?2",
+            params![task_id, agent_id],
+            |row| row.get(0),
+        )?,
+    };
     Ok(count > 0)
 }
 
-fn result_counts(conn: &rusqlite::Connection) -> Result<serde_json::Value, MessagingError> {
-    let total: i64 = conn.query_row("select count(*) from results", [], |row| row.get(0))?;
-    let collected: i64 = conn.query_row(
-        "select count(*) from results where status = 'collected'",
-        [],
-        |row| row.get(0),
-    )?;
-    let invalid: i64 = conn.query_row(
-        "select count(*) from results where status = 'invalid'",
-        [],
-        |row| row.get(0),
-    )?;
+fn result_counts(
+    conn: &rusqlite::Connection,
+    owner_team_id: Option<&str>,
+) -> Result<serde_json::Value, MessagingError> {
+    let total: i64 = count_results(conn, owner_team_id, None)?;
+    let collected: i64 = count_results(conn, owner_team_id, Some("collected"))?;
+    let invalid: i64 = count_results(conn, owner_team_id, Some("invalid"))?;
     let uncollected = total - collected - invalid;
     let mut by_status = serde_json::Map::new();
-    let mut stmt = conn.prepare(
-        "select status, count(*) from results
-         where status not in ('collected', 'invalid')
-         group by status
-         order by status",
-    )?;
-    let rows = stmt.query_map([], |row| Ok((row.get::<_, String>(0)?, row.get::<_, i64>(1)?)))?;
+    let sql = match owner_team_id {
+        Some(_) => {
+            "select status, count(*) from results
+             where status not in ('collected', 'invalid') and owner_team_id = ?1
+             group by status
+             order by status"
+        }
+        None => {
+            "select status, count(*) from results
+             where status not in ('collected', 'invalid')
+             group by status
+             order by status"
+        }
+    };
+    let mut stmt = conn.prepare(sql)?;
+    let row_mapper = |row: &rusqlite::Row<'_>| Ok((row.get::<_, String>(0)?, row.get::<_, i64>(1)?));
+    let rows = match owner_team_id {
+        Some(team) => stmt.query_map(params![team], row_mapper),
+        None => stmt.query_map([], row_mapper),
+    }?;
     for row in rows {
         let (status, count) = row?;
         by_status.insert(status, serde_json::Value::Number(count.into()));
@@ -319,12 +454,45 @@ fn result_counts(conn: &rusqlite::Connection) -> Result<serde_json::Value, Messa
     }))
 }
 
+fn count_results(
+    conn: &rusqlite::Connection,
+    owner_team_id: Option<&str>,
+    status: Option<&str>,
+) -> Result<i64, MessagingError> {
+    match (owner_team_id, status) {
+        (Some(team), Some(status)) => Ok(conn.query_row(
+            "select count(*) from results where owner_team_id = ?1 and status = ?2",
+            params![team, status],
+            |row| row.get(0),
+        )?),
+        (Some(team), None) => Ok(conn.query_row(
+            "select count(*) from results where owner_team_id = ?1",
+            params![team],
+            |row| row.get(0),
+        )?),
+        (None, Some(status)) => Ok(conn.query_row(
+            "select count(*) from results where status = ?1",
+            params![status],
+            |row| row.get(0),
+        )?),
+        (None, None) => Ok(conn.query_row("select count(*) from results", [], |row| row.get(0))?),
+    }
+}
+
 /// `report_result` (`results.py:191`):worker 报结果 —— 校验 envelope、存 result、ack 任务消息、
 /// **排队** send 事件通知 leader、推进 orchestrator (软依赖,失败仅记 `orchestrator.advance_skipped`)。
 /// MCP `report_result` 工具调。
 pub fn report_result(
     workspace: &Path,
     envelope: &serde_json::Value,
+) -> Result<serde_json::Value, MessagingError> {
+    report_result_for_owner_team(workspace, envelope, None)
+}
+
+pub fn report_result_for_owner_team(
+    workspace: &Path,
+    envelope: &serde_json::Value,
+    explicit_owner_team: Option<&str>,
 ) -> Result<serde_json::Value, MessagingError> {
     validate_result_envelope(envelope)?;
     let store = MessageStore::open(workspace)?;
@@ -344,7 +512,10 @@ pub fn report_result(
     let conn = crate::db::schema::open_db(store.db_path())?;
     let state_for_owner = crate::state::persist::load_runtime_state(workspace)
         .unwrap_or(serde_json::json!({}));
-    let owner_team = super::leader_receiver::active_team_key(workspace, &state_for_owner);
+    let owner_team = explicit_owner_team
+        .filter(|team| !team.is_empty())
+        .map(str::to_string)
+        .unwrap_or_else(|| super::leader_receiver::active_team_key(workspace, &state_for_owner));
     let inserted = insert_result_if_absent(
         &conn,
         &result_id,
@@ -360,7 +531,7 @@ pub fn report_result(
             "mcp.report_result_duplicate_ignored",
             serde_json::json!({
                 "notification_status": "duplicate_ignored",
-                "owner_team_id": null,
+                "owner_team_id": owner_team,
                 "result_id": result_id,
             }),
         )?;
@@ -392,7 +563,7 @@ pub fn report_result(
     // legacy path was MUST-8 / I-3 violating (the deferred notification status was returned
     // to the caller as "success" while leader actually never saw the result text).
     let content = format_report_result_notification(&result_id, task_id, agent_id, status, envelope);
-    let state = crate::state::persist::load_runtime_state(workspace).unwrap_or(serde_json::json!({}));
+    let state = report_owner_state(&state_for_owner, &owner_team);
     let event_log = EventLog::new(workspace);
     let mut outcome = super::leader_receiver::send_to_leader_receiver(
         workspace,
@@ -405,19 +576,72 @@ pub fn report_result(
         Some(&result_id),
         &event_log,
     )?;
-    if matches!(outcome.status, crate::messaging::DeliveryStatus::Queued) {
-        if let Some(message_id) = outcome.message_id.clone() {
+    if let Some(message_id) = outcome.message_id.clone() {
             let store = MessageStore::open(workspace)?;
             let transport = crate::tmux_backend::TmuxBackend::for_workspace(workspace);
-            outcome = super::delivery::deliver_pending_message(
-                workspace,
-                &store,
-                &transport,
-                &message_id,
-                &event_log,
-                &state,
-            )?;
-        }
+            let delivery_state_raw = crate::state::persist::load_runtime_state(workspace)
+                .unwrap_or_else(|_| state_for_owner.clone());
+            let delivery_state = report_owner_state(&delivery_state_raw, &owner_team);
+            for attempt in 0..3 {
+                let _ = store.mark(&message_id, "accepted", None);
+                outcome = super::delivery::deliver_pending_message(
+                    workspace,
+                    &store,
+                    &transport,
+                    &message_id,
+                    &event_log,
+                    &delivery_state,
+                )?;
+                if outcome.ok {
+                    break;
+                }
+                let delivered = super::delivery::deliver_pending_messages(
+                    workspace,
+                    &delivery_state,
+                    &transport,
+                    &event_log,
+                )?;
+                if delivered.iter().any(|delivered_id| delivered_id == &message_id) {
+                    outcome = crate::messaging::DeliveryOutcome {
+                        ok: true,
+                        status: crate::messaging::DeliveryStatus::Delivered,
+                        message_status: super::helpers::MessageStatusShadow("delivered".to_string()),
+                        message_id: Some(message_id.clone()),
+                        verification: None,
+                        stage: None,
+                        reason: None,
+                        channel: Some("leader_receiver".to_string()),
+                    };
+                    break;
+                }
+                if attempt < 2 {
+                    std::thread::sleep(std::time::Duration::from_millis(50));
+                }
+            }
+            match inject_leader_notification_direct(workspace, &delivery_state, &content, &message_id) {
+                Ok(()) => {
+                    store.mark(&message_id, "delivered", None)?;
+                    outcome = crate::messaging::DeliveryOutcome {
+                        ok: true,
+                        status: crate::messaging::DeliveryStatus::Delivered,
+                        message_status: super::helpers::MessageStatusShadow("delivered".to_string()),
+                        message_id: Some(message_id),
+                        verification: None,
+                        stage: None,
+                        reason: None,
+                        channel: Some("leader_receiver".to_string()),
+                    };
+                }
+                Err(reason) => {
+                    event_log.write(
+                        "leader_receiver.direct_inject_skipped",
+                        serde_json::json!({
+                            "message_id": message_id,
+                            "reason": reason,
+                        }),
+                    )?;
+                }
+            }
     }
     let leader_notified = outcome.ok;
     let notification_status_wire = if outcome.ok {
@@ -437,7 +661,7 @@ pub fn report_result(
             "notification_channel": channel,
             "notification_message_id": outcome.message_id,
             "notification_status": notification_status_wire,
-            "owner_team_id": null,
+            "owner_team_id": owner_team,
             "result_id": result_id,
         }),
     )?;
@@ -471,6 +695,72 @@ pub fn report_result(
     Ok(serde_json::Value::Object(out))
 }
 
+fn report_owner_state(state: &serde_json::Value, owner_team: &str) -> serde_json::Value {
+    let mut state = match crate::state::projection::resolve_owner_team_id(state, owner_team)
+        .canonical_key()
+    {
+        Some(team) => crate::state::projection::project_top_level_view(state, team),
+        None => state.clone(),
+    };
+    if let Some(obj) = state.as_object_mut() {
+        obj.insert(
+            "active_team_key".to_string(),
+            serde_json::Value::String(owner_team.to_string()),
+        );
+    }
+    state
+}
+
+fn inject_leader_notification_direct(
+    workspace: &Path,
+    state: &serde_json::Value,
+    content: &str,
+    message_id: &str,
+) -> Result<(), String> {
+    let Some(pane_id) = state
+        .get("leader_receiver")
+        .or_else(|| state.get("team_owner"))
+        .and_then(|receiver| receiver.get("pane_id"))
+        .and_then(serde_json::Value::as_str)
+        .filter(|pane| !pane.is_empty() && *pane != "__team_agent_unbound__")
+    else {
+        return Err("leader_direct_inject_failed:no_bound_pane".to_string());
+    };
+    let rendered = format!(
+        "Team Agent message from leader_receiver:\n\n{content}\n\n[team-agent-token:{message_id}]"
+    );
+    let target = Target::Pane(PaneId::new(pane_id));
+    if let Some(socket) = state
+        .get("leader_receiver")
+        .and_then(|receiver| receiver.get("tmux_socket"))
+        .and_then(serde_json::Value::as_str)
+        .filter(|socket| !socket.is_empty())
+    {
+        let backend = crate::tmux_backend::TmuxBackend::for_tmux_endpoint(socket);
+        if backend
+            .inject(&target, &InjectPayload::Text(rendered.clone()), Key::Enter, true)
+            .is_ok()
+        {
+            return Ok(());
+        }
+    }
+    let workspace_backend = crate::tmux_backend::TmuxBackend::for_workspace(workspace);
+    if workspace_backend
+        .inject(&target, &InjectPayload::Text(rendered.clone()), Key::Enter, true)
+        .is_ok()
+    {
+        return Ok(());
+    }
+    let default_backend = crate::tmux_backend::TmuxBackend::new();
+    if default_backend
+        .inject(&target, &InjectPayload::Text(rendered), Key::Enter, true)
+        .is_ok()
+    {
+        return Ok(());
+    }
+    Err(format!("leader_direct_inject_failed:pane={pane_id}"))
+}
+
 fn insert_result_if_absent(
     conn: &rusqlite::Connection,
     result_id: &str,