@team-agent/installer 0.3.2 → 0.3.4

package/crates/team-agent/src/message_store.rs

@@ -31,7 +31,7 @@
 
 use std::path::Path;
 use std::sync::atomic::{AtomicU64, Ordering};
-use std::time::{SystemTime, UNIX_EPOCH};
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
 use rusqlite::{params, OptionalExtension};
 use thiserror::Error;
@@ -100,8 +100,25 @@ impl MessageStore {
         let runtime_dir = workspace.join(".team").join("runtime");
         std::fs::create_dir_all(&runtime_dir)?;
         let path = runtime_dir.join("team.db");
+        let existed = path.exists();
         let conn = crate::db::schema::open_db(&path)?;
-        crate::db::schema::initialize_schema(&conn, Some(&path))?;
+        if existed {
+            conn.busy_timeout(Duration::from_millis(5))?;
+            let version = conn.query_row("pragma user_version", [], |row| row.get::<_, i64>(0));
+            conn.busy_timeout(Duration::from_millis(30_000))?;
+            match version {
+                Ok(version) if version == crate::db::schema::SCHEMA_VERSION => {}
+                Ok(_) => crate::db::schema::initialize_schema(&conn, Some(&path))?,
+                Err(rusqlite::Error::SqliteFailure(err, _))
+                    if matches!(
+                        err.code,
+                        rusqlite::ErrorCode::DatabaseBusy | rusqlite::ErrorCode::DatabaseLocked
+                    ) => {}
+                Err(error) => return Err(error.into()),
+            }
+        } else {
+            crate::db::schema::initialize_schema(&conn, Some(&path))?;
+        }
         Ok(Self { path })
     }
 
@@ -220,12 +237,12 @@ impl MessageStore {
              end,
              updated_at = ?3,
              delivered_at = case
-                 when ?2 in ('injected', 'visible', 'submitted', 'submitted_unverified', 'delivered')
+                 when ?2 in ('injected', 'visible', 'submitted', 'delivered')
                  then ?3
                  else delivered_at
              end,
              acknowledged_at = case when ?2 = 'acknowledged' then ?3 else acknowledged_at end,
-             error = coalesce(?4, error)
+             error = case when ?2 = 'delivered' then null else coalesce(?4, error) end
              where message_id = ?1",
             params![message_id, status, now, error],
         )?;

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

@@ -115,18 +115,6 @@ pub fn deliver_pending_message(
         });
     }
     let message = message_for_delivery(store, message_id)?;
-    if !store.claim_for_delivery(message_id)? {
-        return Ok(DeliveryOutcome {
-            ok: false,
-            status: DeliveryStatus::Refused,
-            message_status: MessageStatusShadow("target_resolved".to_string()),
-            message_id: Some(message_id.to_string()),
-            verification: None,
-            stage: None,
-            reason: Some(DeliveryRefusal::MessageAlreadyClaimed),
-            channel: None,
-        });
-    }
     let Some(message) = message else {
         return Ok(DeliveryOutcome {
             ok: false,
@@ -154,6 +142,18 @@ pub fn deliver_pending_message(
         }
         _ => state,
     };
+    if !store.claim_for_delivery(message_id)? && message.status != "target_resolved" {
+        return Ok(DeliveryOutcome {
+            ok: false,
+            status: DeliveryStatus::Refused,
+            message_status: MessageStatusShadow("target_resolved".to_string()),
+            message_id: Some(message_id.to_string()),
+            verification: None,
+            stage: None,
+            reason: Some(DeliveryRefusal::MessageAlreadyClaimed),
+            channel: None,
+        });
+    }
     if message.recipient == "leader" && leader_receiver_has_noncanonical_tmux_socket(state) {
         store.mark(message_id, "failed", Some("leader_not_attached"))?;
         event_log.write(
@@ -244,7 +244,6 @@ pub fn deliver_pending_message(
         &message.content,
         message_id,
     );
-    let rendered_len = rendered.len();
     let inject_report = match transport.inject(
         &target,
         &InjectPayload::Text(rendered),
@@ -282,7 +281,7 @@ pub fn deliver_pending_message(
             return Err(error.into());
         }
     };
-    if !inject_submit_verified(&inject_report, rendered_len, &message.sender, &message.recipient) {
+    if !inject_submit_verified(&inject_report) {
         let reason = format!(
             "submit_unverified:{}",
             submit_verification_wire(inject_report.submit_verification)
@@ -340,19 +339,13 @@ pub fn deliver_pending_message(
     Ok(outcome)
 }
 
-fn inject_submit_verified(
-    report: &InjectReport,
-    payload_len: usize,
-    sender: &str,
-    recipient: &str,
-) -> bool {
+fn inject_submit_verified(report: &InjectReport) -> bool {
     match report.submit_verification {
         SubmitVerification::SendKeysFailed => false,
+        SubmitVerification::PastedContentPromptStillPresentAfterSubmit => false,
         SubmitVerification::PastedContentPromptAbsentAfterSubmit => true,
         SubmitVerification::KeySentAfterVisibleToken { .. } => true,
-        SubmitVerification::EnterSentWithoutPlaceholderCheck => {
-            recipient == "leader" || matches!(sender, "leader" | "Leader") || payload_len < 80
-        }
+        SubmitVerification::EnterSentWithoutPlaceholderCheck => true,
     }
 }
 
@@ -450,13 +443,60 @@ fn delivery_transport_for_recipient<'a>(
     if recipient != "leader" {
         return DeliveryTransport::Borrowed(product_transport);
     }
+    let pane_id = leader_receiver_pane_id(state);
     let Some(socket) = leader_receiver_tmux_socket(state) else {
+        if let Some(pane_id) = pane_id {
+            let in_workspace = product_transport
+                .list_targets()
+                .unwrap_or_default()
+                .iter()
+                .any(|target| target.pane_id.as_str() == pane_id);
+            if !in_workspace {
+                let default_backend = crate::tmux_backend::TmuxBackend::new();
+                if default_backend
+                    .list_targets()
+                    .unwrap_or_default()
+                    .iter()
+                    .any(|target| target.pane_id.as_str() == pane_id)
+                {
+                    return DeliveryTransport::Owned(default_backend);
+                }
+            }
+        }
         return DeliveryTransport::Borrowed(product_transport);
     };
     if socket == crate::tmux_backend::socket_name_for_workspace(workspace) {
         DeliveryTransport::Borrowed(product_transport)
     } else {
-        DeliveryTransport::Owned(crate::tmux_backend::TmuxBackend::for_tmux_endpoint(socket))
+        let endpoint_backend = crate::tmux_backend::TmuxBackend::for_tmux_endpoint(socket);
+        if let Some(pane_id) = pane_id {
+            if endpoint_backend
+                .list_targets()
+                .unwrap_or_default()
+                .iter()
+                .any(|target| target.pane_id.as_str() == pane_id)
+            {
+                return DeliveryTransport::Owned(endpoint_backend);
+            }
+            if product_transport
+                .list_targets()
+                .unwrap_or_default()
+                .iter()
+                .any(|target| target.pane_id.as_str() == pane_id)
+            {
+                return DeliveryTransport::Borrowed(product_transport);
+            }
+            let default_backend = crate::tmux_backend::TmuxBackend::new();
+            if default_backend
+                .list_targets()
+                .unwrap_or_default()
+                .iter()
+                .any(|target| target.pane_id.as_str() == pane_id)
+            {
+                return DeliveryTransport::Owned(default_backend);
+            }
+        }
+        DeliveryTransport::Owned(endpoint_backend)
     }
 }
 
@@ -466,7 +506,7 @@ fn leader_receiver_pane_id_in_state(state: &serde_json::Value) -> Option<&str> {
             .get(key)
             .and_then(|r| r.get("pane_id"))
             .and_then(serde_json::Value::as_str)
-            .filter(|s| !s.is_empty())
+            .filter(|s| !s.is_empty() && *s != "__team_agent_unbound__")
     })
 }
 
@@ -528,7 +568,7 @@ pub fn deliver_pending_messages(
         let conn = crate::db::schema::open_db(store.db_path())?;
         let mut stmt = conn.prepare(
             "select message_id from messages
-             where status in ('pending', 'accepted')
+             where status in ('pending', 'accepted', 'target_resolved')
              order by created_at, message_id",
         )?;
         let rows = stmt.query_map([], |row| row.get::<_, String>(0))?;
@@ -577,6 +617,7 @@ struct PendingMessage {
     content: String,
     task_id: Option<String>,
     owner_team_id: Option<String>,
+    status: String,
 }
 
 fn message_for_delivery(
@@ -586,7 +627,7 @@ fn message_for_delivery(
     let conn = crate::db::schema::open_db(store.db_path())?;
     let message = conn
         .query_row(
-            "select sender, recipient, content, task_id, owner_team_id from messages where message_id = ?1",
+            "select sender, recipient, content, task_id, owner_team_id, status from messages where message_id = ?1",
             params![message_id],
             |row| {
                 Ok(PendingMessage {
@@ -595,6 +636,7 @@ fn message_for_delivery(
                     content: row.get::<_, String>(2)?,
                     task_id: row.get::<_, Option<String>>(3)?,
                     owner_team_id: row.get::<_, Option<String>>(4)?,
+                    status: row.get::<_, String>(5)?,
                 })
             },
         )
@@ -603,10 +645,11 @@ fn message_for_delivery(
 }
 
 /// Pre-inject gate (Contract B): peek the recipient pane and answer "is there an
-/// actionable Codex startup prompt right now (trust menu or update prompt)" using
-/// the SHARED provider/startup_prompt recognizer — no second classifier, no provider
-/// API calls. Returns `false` if capture fails so non-Codex providers (or any pane
-/// without the trust-menu shape) keep flowing through normal delivery.
+/// actionable provider startup prompt right now (trust menu or update prompt)" using
+/// the SHARED provider/startup_prompt recognizers — no second classifier, no provider
+/// API calls. Returns `false` if capture fails so providers without a startup
+/// recognizer (or any pane without the trust-menu shape) keep flowing through
+/// normal delivery.
 fn recipient_pane_has_actionable_startup_prompt(
     transport: &dyn Transport,
     state: &serde_json::Value,
@@ -620,7 +663,7 @@ fn recipient_pane_has_actionable_startup_prompt(
     let provider = agent
         .and_then(|agent| agent.get("provider"))
         .and_then(serde_json::Value::as_str);
-    if !matches!(provider, Some("codex")) {
+    if !matches!(provider, Some("codex" | "claude" | "claude_code")) {
         return false;
     }
     // step2-retry/scrollback root-cause (rt binary 6c9c6c1c): once the agent's
@@ -643,11 +686,18 @@ fn recipient_pane_has_actionable_startup_prompt(
         Ok(Ok(captured)) => captured.text,
         _ => return false,
     };
-    matches!(
-        crate::provider::classify_codex_startup_screen(&captured),
-        crate::provider::StartupScreenDecision::AnswerWorkspaceTrust
-            | crate::provider::StartupScreenDecision::SkipUpdatePrompt
-    )
+    match provider {
+        Some("codex") => matches!(
+            crate::provider::classify_codex_startup_screen(&captured),
+            crate::provider::StartupScreenDecision::AnswerWorkspaceTrust
+                | crate::provider::StartupScreenDecision::SkipUpdatePrompt
+        ),
+        Some("claude" | "claude_code") => matches!(
+            crate::provider::classify_claude_startup_screen(&captured),
+            crate::provider::StartupScreenDecision::AnswerWorkspaceTrust
+        ),
+        _ => false,
+    }
 }
 
 fn recipient_is_busy(state: &serde_json::Value, recipient: &str) -> bool {

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_for_team, 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,6 +6,7 @@ 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;
@@ -98,11 +99,13 @@ fn collect_scoped(
     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;
     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,
@@ -114,6 +117,7 @@ fn collect_scoped(
             }
         };
         if let Err(error) = validate_result_envelope(&envelope) {
+            fatal_invalid_results = fatal_invalid_results.saturating_add(1);
             record_invalid_result(
                 &conn,
                 &mut invalid_results,
@@ -128,6 +132,9 @@ fn collect_scoped(
         } 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,
@@ -189,7 +196,7 @@ fn collect_scoped(
     }
     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": [],
@@ -478,6 +485,14 @@ fn count_results(
 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)?;
@@ -497,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,
@@ -513,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,
             }),
         )?;
@@ -545,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,
@@ -558,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 {
@@ -590,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,
         }),
     )?;
@@ -624,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,