@team-agent/installer 0.5.114 → 0.5.116

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

@@ -2,7 +2,7 @@
 //! implicit business retry, queue flush, or replay of uncertain messages.
 use super::{
     backend::{self, Backend, BackendError},
-    forward, framework,
+    forward, framework, registry,
 };
 use serde_json::Value;
 use std::path::Path;
@@ -12,11 +12,10 @@ use team_agent_contract::host::{
     clock::{Clock, RealClock},
     process::verify_native_ancestry,
 };
-use team_agent_contract::kiro::{interaction, KIRO_DESCRIPTOR};
 use team_agent_contract::orchestration::{physical::*, store::*, supervisor::*};
 use team_agent_contract::runtime::probes::*;
 
-fn protocol(
+pub(super) fn protocol(
     backend: &mut Backend,
     seat: &SeatRecord,
     clock: &RealClock,
@@ -28,6 +27,9 @@ fn protocol(
         .into_iter()
         .filter(|record| {
             !record.closed
+                && record.identity == seat.identity
+                && record.server_key == seat.server_key
+                && record.binding_key == seat.binding_key
                 && record.native_process == target.process
                 && verify_native_ancestry(&record.process, &record.native_process).is_ok()
         })
@@ -75,6 +77,35 @@ fn protocol(
             });
         }
     }
+    if registry::provider(seat.provider.as_str())?.uses_tool_roundtrips() {
+        let session = seat.session.as_ref().ok_or(BackendError::Metadata)?;
+        if target.identity() != &seat.identity || target.binding != seat.binding_key
+            || target.provider != seat.provider || target.native != seat.native
+            || target.native_session.as_ref() != Some(&session.native_session)
+            || session.source != seat.identity || session.provider != seat.provider
+            || session.native != seat.native || session.cwd != target.cwd
+            || target.candidate_sha256 != backend.binding.candidate_sha256
+        {
+            return Err(ContractError::Mismatch("native roundtrip current binding").into());
+        }
+        // The core returns only per-tool invocation + actual successful
+        // write/flush pairs for THIS captured connection and generation.
+        // Server list writes or another connection's facts cannot qualify.
+        let tools = backend.store.completed_connection_tools(&seat.identity, &connection.connection)?;
+        if !tools.is_empty() {
+            events.push(ProtocolEvent {
+                scope: target.scope(events.len() as u64, clock.now(), Duration::from_secs(2),
+                    "live-native-tool-roundtrip-ledger"),
+                fact: ProtocolFact::ClientBound {
+                    server_instance: connection.connection.clone(),
+                    evidence: ClientBindingEvidence {
+                        server_key: seat.server_key.clone(), tools,
+                        source: ClientBindingSource::NativeToolRoundtrip,
+                    },
+                },
+            });
+        }
+    }
     Ok(collect_protocol(
         target,
         &connection.connection,
@@ -91,8 +122,18 @@ fn deliver_one(backend: &mut Backend, seat: &SeatRecord) -> Result<(), BackendEr
     {
         return Ok(());
     }
+    let selected = registry::provider(seat.provider.as_str())?;
+    let bootstrap_allowed = selected.first_business_bootstrap() && !seat.bootstrap_used;
+    let profiles = selected.descriptor().input.profiles.require("native input profiles")?;
+    let profile = profiles.iter().find(|profile| profile.id == seat.profile && profile.matches_native(&seat.native))
+        .ok_or(ContractError::ProfileUnavailable)?;
+    profile.policy.require("native submit policy")?;
+    let role = backend::read_role(&backend.binding, &seat.identity)?;
+    if role.provider != seat.provider {
+        return Err(BackendError::Metadata);
+    }
     let clock = RealClock::new();
-    let adapter = backend::adapter(&backend.binding, &seat.identity)?;
+    let adapter = backend::adapter(&backend.binding, &seat.identity, &seat.provider)?;
     let hooks = adapter.hooks();
     let operation = OperationId::new(format!(
         "deliver-{}",
@@ -104,15 +145,19 @@ fn deliver_one(backend: &mut Backend, seat: &SeatRecord) -> Result<(), BackendEr
     ))?;
     let mut physical = PhysicalRuntime::new(
         Registration {
-            descriptor: &KIRO_DESCRIPTOR,
+            descriptor: selected.descriptor(),
             hooks: &hooks,
-            controls: interaction::CONTROLS,
+            controls: selected.controls(),
+            startup: selected.startup(),
+            session_panel: selected.session_panel(),
         },
-        backend::settings(&backend.binding),
+        backend::settings(&backend.binding, selected),
         operation.clone(),
         &clock,
     )?;
-    physical.evidence = backend::policy_evidence(&seat.native, backend.binding.candidate_sha256);
+    physical.evidence = backend::policy_evidence(
+        &seat.provider, &seat.native, backend.binding.candidate_sha256,
+    )?;
     physical.protocol = Some(protocol(backend, seat, &clock)?);
     let sample = physical.readiness(seat)?;
     if !matches!(sample.pane.outcome, ProbeOutcome::Observed(ref pane) if pane.surface == InputSurface::ComposerReady)
@@ -120,28 +165,39 @@ fn deliver_one(backend: &mut Backend, seat: &SeatRecord) -> Result<(), BackendEr
     {
         return Ok(());
     }
-    backend
-        .store
-        .begin_observation(&seat.identity, &operation)?;
-    // A completed-but-uncertain inspector quarantines the seat, without an
-    // orphan lease that would prevent explicit scoped shutdown. No replay or
-    // blind Escape to clear an unrelated approval/composer is permitted.
-    let binding = match physical.client_binding(seat, &interaction::TOOL_PANEL) {
-        Ok(binding) => binding,
-        Err(error) => {
-            backend.store.fail_observation(&seat.identity, &operation)?;
-            return Err(error.into());
+    // A roundtrip provider consumes only its captured protocol evidence. An
+    // Unknown/partial binding is left to the typed readiness gate; it never
+    // triggers a guessed TUI /tools command or a Kiro inspector fallback.
+    if !bootstrap_allowed && !selected.uses_tool_roundtrips() {
+        let panel = selected.tool_panel()?;
+        if panel.profile_id != seat.profile || panel.server_key != seat.server_key
+            || panel.policy_sha256 != profile.policy_sha256
+        {
+            return Err(ContractError::Mismatch("native inspector seat binding").into());
         }
-    };
-    backend
-        .store
-        .finish_observation(&seat.identity, &operation)?;
-    if !matches!(binding.outcome, ProbeOutcome::Observed(_)) {
-        return Ok(());
+        backend.store.begin_observation(&seat.identity, &operation)?;
+        // Uncertain inspection quarantines the seat without an orphan lease.
+        // No replay or blind Escape clears an unrelated composer/approval.
+        let binding = match physical.client_binding(seat, panel) {
+            Ok(binding) => binding,
+            Err(error) => {
+                backend.store.fail_observation(&seat.identity, &operation)?;
+                return Err(error.into());
+            }
+        };
+        backend.store.finish_observation(&seat.identity, &operation)?;
+        if !matches!(binding.outcome, ProbeOutcome::Observed(_)) {
+            return Ok(());
+        }
+        let mut current_protocol = protocol(backend, seat, &clock)?;
+        current_protocol.binding = binding;
+        physical.protocol = Some(current_protocol);
+    }
+    // H3's owned prompt receipt is independently checked by PhysicalRuntime;
+    // only the one durable first-business claim can carry this instruction.
+    if bootstrap_allowed {
+        physical.initial_prompt = Some(role.prompt.text.clone());
     }
-    let mut current_protocol = protocol(backend, seat, &clock)?;
-    current_protocol.binding = binding;
-    physical.protocol = Some(current_protocol);
     let mut bootstrap = OutboxBootstrap::new(ContractStore::open(
         &backend.binding.transport_root,
         backend.binding.scope.clone(),
@@ -150,10 +206,10 @@ fn deliver_one(backend: &mut Backend, seat: &SeatRecord) -> Result<(), BackendEr
     physical.bootstrap = Some(&mut bootstrap);
     let sample = physical.readiness(seat)?;
     let authorization = DeliveryAuthorization {
-        allow_first_business_bootstrap: false,
+        allow_first_business_bootstrap: bootstrap_allowed,
         require_server_handshake: true,
         channel: Channel::Tmux,
-        policy_sha256: interaction::POLICY,
+        policy_sha256: profile.policy_sha256,
     };
     let _ = team_agent_contract::orchestration::supervisor::tick(
         &mut backend.store,
@@ -170,15 +226,18 @@ pub fn tick(workspace: &Path, state: &mut Value) -> Result<(), BackendError> {
         return Ok(());
     }
     let team = crate::state::projection::team_state_key(state);
-    let mut backend = Backend::open(workspace, &team)?;
     let ids: Vec<_> = state
         .get("agents")
         .and_then(Value::as_object)
         .into_iter()
         .flat_map(|agents| agents.iter())
-        .filter(|(_, agent)| framework::is_contract(agent))
+        .filter(|(_, agent)| framework::is_contract(agent) && !framework::is_paused_unstarted(agent))
         .map(|(id, _)| id.clone())
         .collect();
+    if ids.is_empty() {
+        return Ok(());
+    }
+    let mut backend = Backend::open(workspace, &team)?;
     let mut failure = None;
     for id in ids {
         let Some(seat) = backend.store.seat(&SeatId::new(&id)?)? else {
@@ -192,7 +251,12 @@ pub fn tick(workspace: &Path, state: &mut Value) -> Result<(), BackendError> {
             .and_then(|agents| agents.get_mut(&id))
         {
             match framework::project_seat(workspace, &team, &id) {
-                Ok(projected) => *agent = projected,
+                Ok(projected) => {
+                    let row = agent.as_object_mut().ok_or(BackendError::Metadata)?;
+                    for (key, value) in projected.as_object().ok_or(BackendError::Metadata)? {
+                        row.insert(key.clone(), value.clone());
+                    }
+                },
                 Err(error) => failure = Some(error),
             }
         }

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

@@ -1,9 +1,195 @@
-//! The sole new-runtime provider registration. This is not an admission claim:
+//! The sole new-runtime provider registry. This is not an admission claim:
 //! the descriptor's Unverified gates still apply to each requested operation.
-use team_agent_contract::contract::descriptor::ProviderDescriptor;
-use team_agent_contract::kiro::KIRO_DESCRIPTOR;
+use std::collections::BTreeMap;
+use std::path::PathBuf;
+use team_agent_contract::contract::{
+    descriptor::{PromptCarrier, ProviderDescriptor, ToolNaming},
+    types::InstanceIdentity,
+    hooks::{PlanHook, ProviderHooks},
+    plan::{LaunchPlan, ResolvedLaunch},
+    types::{ContractError, Support},
+};
+use team_agent_contract::kiro::{self, KiroAdapter, KIRO_DESCRIPTOR};
+use team_agent_contract::providers::cursor::{self, CursorAdapter, CURSOR_DESCRIPTOR};
+use team_agent_contract::providers::grok_build::{self, GrokAdapter, GROK_BUILD_DESCRIPTOR};
+use team_agent_contract::runtime::{
+    delivery::{ControlDefinition, StartupDefinition},
+    native_panel::{NativePanelPolicy, SessionPanelPolicy},
+};
 
-const DESCRIPTORS: &[&ProviderDescriptor] = &[&KIRO_DESCRIPTOR];
+const DESCRIPTORS: &[&ProviderDescriptor] = &[&KIRO_DESCRIPTOR, &CURSOR_DESCRIPTOR, &GROK_BUILD_DESCRIPTOR];
+
+#[derive(Clone)]
+pub enum NativeRuntime {
+    Cursor(cursor::native::RuntimeInstallation),
+    GrokBuild(grok_build::native::RuntimeInstallation),
+}
+
+/// Leaf selection stays here; the framework, lifecycle and outbox remain shared.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(super) enum NativeProvider {
+    Kiro,
+    Cursor,
+    GrokBuild,
+}
+
+impl NativeProvider {
+    pub fn descriptor(self) -> &'static ProviderDescriptor {
+        match self {
+            Self::Kiro => &KIRO_DESCRIPTOR,
+            Self::Cursor => &CURSOR_DESCRIPTOR,
+            Self::GrokBuild => &GROK_BUILD_DESCRIPTOR,
+        }
+    }
+
+    pub fn action_budget(self) -> std::time::Duration {
+        // Kiro's existing budget is unchanged; Cursor's measured cold-ready
+        // path needs a larger finite bound, not an unbounded readiness wait.
+        std::time::Duration::from_secs(match self { Self::Kiro => 30, Self::Cursor | Self::GrokBuild => 90 })
+    }
+
+    pub fn controls(self) -> &'static [ControlDefinition] {
+        match self {
+            Self::Kiro => kiro::interaction::CONTROLS,
+            Self::Cursor => cursor::interaction::CONTROLS,
+            Self::GrokBuild => grok_build::interaction::CONTROLS,
+        }
+    }
+
+    /// A terminal instruction bridge needs one durable, authorized first packet
+    /// before the native client can demonstrate its Team-tool registry.
+    pub fn first_business_bootstrap(self) -> bool {
+        matches!(self.descriptor().prompt.carrier, Support::Supported(PromptCarrier::RuntimeBridge))
+    }
+
+    /// These providers use the separately fenced native tool-roundtrip ledger,
+    /// never a guessed neutral tools panel or another provider's inspector.
+    pub fn uses_tool_roundtrips(self) -> bool {
+        matches!(self, Self::Cursor | Self::GrokBuild)
+    }
+
+    pub fn startup(self) -> Option<&'static StartupDefinition> {
+        match self {
+            Self::GrokBuild => Some(&grok_build::interaction::STARTUP),
+            Self::Kiro | Self::Cursor => None,
+        }
+    }
+
+    pub fn session_panel(self) -> Option<&'static SessionPanelPolicy> {
+        match self {
+            Self::GrokBuild => Some(&grok_build::interaction::SESSION_PANEL),
+            Self::Kiro | Self::Cursor => None,
+        }
+    }
+
+    pub fn tool_panel(self) -> Result<&'static NativePanelPolicy, ContractError> {
+        match self {
+            Self::Kiro => Ok(&kiro::interaction::TOOL_PANEL),
+            Self::Cursor => Err(ContractError::Unverified {
+                field: "Cursor native Team-tool inspector",
+                reason: cursor::UNVERIFIED,
+            }),
+            Self::GrokBuild => Err(ContractError::Unverified {
+                field: "Grok Build native Team-tool inspector",
+                reason: grok_build::UNVERIFIED,
+            }),
+        }
+    }
+
+    pub fn server_key_for(self, identity: &InstanceIdentity) -> Result<String, ContractError> {
+        if self == Self::GrokBuild {
+            return Ok(grok_build::server_key(identity));
+        }
+        Ok(self.server_key()?.into())
+    }
+
+    pub fn server_key(self) -> Result<&'static str, ContractError> {
+        match self.descriptor().tool_names.naming.require("tool naming")? {
+            ToolNaming::StaticServer { key } => Ok(key),
+            ToolNaming::RuntimeBound => Err(ContractError::Invalid("runtime server-key receipt required")),
+        }
+    }
+
+    pub fn adapter(
+        self,
+        executable: PathBuf,
+        arguments: Vec<String>,
+        environment: BTreeMap<String, String>,
+    ) -> Result<NativeAdapter, ContractError> {
+        match self {
+            Self::Kiro => KiroAdapter::new(kiro::McpStdio {
+                executable, arguments, environment,
+            }).map(NativeAdapter::Kiro),
+            Self::Cursor => CursorAdapter::new(cursor::McpStdio {
+                executable, arguments, environment,
+            }).map(NativeAdapter::Cursor),
+            Self::GrokBuild => GrokAdapter::new(grok_build::McpStdio {
+                executable, arguments, environment,
+            }).map(NativeAdapter::GrokBuild),
+        }
+    }
+}
+
+pub(super) enum NativeAdapter {
+    Kiro(KiroAdapter),
+    Cursor(CursorAdapter),
+    GrokBuild(GrokAdapter),
+}
+
+impl NativeAdapter {
+    pub fn with_launch_context(
+        self,
+        project: PathBuf,
+        runtime: Option<NativeRuntime>,
+    ) -> Result<Self, ContractError> {
+        match self {
+            Self::Kiro(adapter) if runtime.is_none() => Ok(Self::Kiro(adapter)),
+            Self::Kiro(_) => Err(ContractError::Mismatch("native runtime provider")),
+            Self::Cursor(adapter) => {
+                let adapter = adapter.with_project(project)?;
+                Ok(Self::Cursor(match runtime {
+                    Some(NativeRuntime::Cursor(runtime)) => adapter.with_runtime(runtime),
+                    Some(_) => return Err(ContractError::Mismatch("native runtime provider")),
+                    None => adapter,
+                }))
+            }
+            Self::GrokBuild(adapter) => {
+                let adapter = adapter.with_project(project)?;
+                Ok(Self::GrokBuild(match runtime {
+                    Some(NativeRuntime::GrokBuild(runtime)) => adapter.with_runtime(runtime),
+                    Some(_) => return Err(ContractError::Mismatch("native runtime provider")),
+                    None => adapter,
+                }))
+            }
+        }
+    }
+
+    pub fn hooks(&self) -> ProviderHooks<'_> {
+        match self {
+            Self::Kiro(adapter) => adapter.hooks(),
+            Self::Cursor(adapter) => adapter.hooks(),
+            Self::GrokBuild(adapter) => adapter.hooks(),
+        }
+    }
+
+    pub fn plan(&self, request: &ResolvedLaunch) -> Result<LaunchPlan, ContractError> {
+        match self {
+            Self::Kiro(adapter) => adapter.plan(request),
+            Self::Cursor(adapter) => adapter.plan(request),
+            Self::GrokBuild(adapter) => adapter.plan(request),
+        }
+    }
+}
+
+pub(super) fn provider(key: &str) -> Result<NativeProvider, ContractError> {
+    let descriptor = descriptor(key).ok_or(ContractError::Invalid("unregistered contract provider"))?;
+    match descriptor.identity.id {
+        "kiro" => Ok(NativeProvider::Kiro),
+        "cursor" => Ok(NativeProvider::Cursor),
+        "grok_build" => Ok(NativeProvider::GrokBuild),
+        _ => Err(ContractError::Invalid("contract provider dispatcher")),
+    }
+}
 
 pub(crate) fn descriptors() -> &'static [&'static ProviderDescriptor] {
     DESCRIPTORS
@@ -28,3 +214,61 @@ pub fn recognizes(key: &str) -> bool {
                 .any(|alias| alias.eq_ignore_ascii_case(key))
     })
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn canonical_cursor_does_not_reclassify_legacy_names() {
+        assert_eq!(provider("cursor").unwrap(), NativeProvider::Cursor);
+        assert_eq!(provider("kiro").unwrap(), NativeProvider::Kiro);
+        for legacy in ["cursor_agent", "agent", "pi", "codex", "grok"] {
+            assert!(descriptor(legacy).is_none());
+            assert!(!recognizes(legacy));
+            assert!(provider(legacy).is_err());
+        }
+        assert_eq!(provider("grok_build").unwrap(), NativeProvider::GrokBuild);
+        assert!(recognizes(" Grok_Build "));
+        assert!(descriptor("Grok_Build").is_none());
+        assert!(GROK_BUILD_DESCRIPTOR.identity.aliases.is_empty());
+        assert!(recognizes(" Cursor "));
+        assert!(descriptor("Cursor").is_none());
+        for descriptor in descriptors() {
+            assert_eq!(provider(descriptor.identity.id).unwrap().descriptor(), *descriptor);
+        }
+    }
+
+    #[test]
+    fn grok_server_key_is_generation_bound_and_has_no_inspector_fallback() {
+        use team_agent_contract::contract::types::{Generation, InstanceId, ScopeId, SeatId};
+        let mut identity = InstanceIdentity {
+            scope: ScopeId::new("scope").unwrap(), seat: SeatId::new("worker").unwrap(),
+            instance: InstanceId::new("instance").unwrap(), generation: Generation(1),
+        };
+        let first = NativeProvider::GrokBuild.server_key_for(&identity).unwrap();
+        assert_eq!(first, grok_build::server_key(&identity));
+        identity.generation = Generation(2);
+        assert_ne!(first, NativeProvider::GrokBuild.server_key_for(&identity).unwrap());
+        assert!(NativeProvider::GrokBuild.server_key().is_err());
+        assert!(NativeProvider::GrokBuild.tool_panel().is_err());
+        assert!(NativeProvider::GrokBuild.startup().is_some());
+        assert!(NativeProvider::GrokBuild.session_panel().is_some());
+        assert!(NativeProvider::GrokBuild.uses_tool_roundtrips());
+    }
+
+    #[test]
+    fn cursor_has_no_kiro_control_or_tool_inspector_fallback() {
+        assert!(NativeProvider::Cursor.controls().is_empty());
+        assert!(matches!(NativeProvider::Cursor.tool_panel(), Err(ContractError::Unverified { .. })));
+        assert_eq!(NativeProvider::Cursor.server_key().unwrap(), "team");
+        assert!(NativeProvider::Cursor.first_business_bootstrap());
+        assert!(NativeProvider::Cursor.uses_tool_roundtrips());
+        assert!(!NativeProvider::Kiro.first_business_bootstrap());
+        assert!(!NativeProvider::Kiro.uses_tool_roundtrips());
+        let kiro_panel = NativeProvider::Kiro.tool_panel().unwrap();
+        assert_eq!(kiro_panel.server_key, NativeProvider::Kiro.server_key().unwrap());
+        assert_eq!(kiro_panel.policy_sha256, kiro::interaction::POLICY);
+        assert!(!NativeProvider::Kiro.controls().is_empty());
+    }
+}