@team-agent/installer 0.5.113 → 0.5.114

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

@@ -0,0 +1,207 @@
+//! One coordinator-owned consumer of the K3 outbox. No CLI send side channel,
+//! implicit business retry, queue flush, or replay of uncertain messages.
+use super::{
+    backend::{self, Backend, BackendError},
+    forward, framework,
+};
+use serde_json::Value;
+use std::path::Path;
+use std::time::Duration;
+use team_agent_contract::contract::{delivery::InputSurface, probe::*, types::*};
+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(
+    backend: &mut Backend,
+    seat: &SeatRecord,
+    clock: &RealClock,
+) -> Result<ProtocolSnapshot, BackendError> {
+    let target = seat.physical.as_ref().ok_or(BackendError::Metadata)?;
+    let active: Vec<_> = backend
+        .store
+        .connections(&seat.identity)?
+        .into_iter()
+        .filter(|record| {
+            !record.closed
+                && record.native_process == target.process
+                && verify_native_ancestry(&record.process, &record.native_process).is_ok()
+        })
+        .collect();
+    if active.len() != 1 {
+        return Ok(collect_protocol(
+            target,
+            &seat.identity.instance,
+            &seat.server_key,
+            &[],
+            clock.now(),
+            Duration::from_secs(2),
+        ));
+    }
+    let connection = &active[0];
+    let facts = backend
+        .store
+        .connection_facts(&seat.identity, &connection.connection)?;
+    let mut events = Vec::new();
+    // T3a is connection state, sampled against BOTH captured process births.
+    // Completed server writes are never promoted to client discovery.
+    for (fact, protocol) in [
+        (
+            "initialize_response_written",
+            ProtocolFact::InitializeResponseWritten {
+                server_instance: connection.connection.clone(),
+            },
+        ),
+        (
+            "tools_list_response_written",
+            ProtocolFact::ToolsListResponseWritten {
+                server_instance: connection.connection.clone(),
+            },
+        ),
+    ] {
+        if facts.iter().any(|value| value == fact) {
+            events.push(ProtocolEvent {
+                scope: target.scope(
+                    events.len() as u64,
+                    clock.now(),
+                    Duration::from_secs(2),
+                    "live-owned-stdio-state",
+                ),
+                fact: protocol,
+            });
+        }
+    }
+    Ok(collect_protocol(
+        target,
+        &connection.connection,
+        &seat.server_key,
+        &events,
+        clock.now(),
+        Duration::from_secs(2),
+    ))
+}
+
+fn deliver_one(backend: &mut Backend, seat: &SeatRecord) -> Result<(), BackendError> {
+    if matches!(seat.status, SeatStatus::Stopped | SeatStatus::Unknown)
+        || !backend.store.has_queued_for(&seat.identity)?
+    {
+        return Ok(());
+    }
+    let clock = RealClock::new();
+    let adapter = backend::adapter(&backend.binding, &seat.identity)?;
+    let hooks = adapter.hooks();
+    let operation = OperationId::new(format!(
+        "deliver-{}",
+        backend
+            .store
+            .propose_identity(&seat.identity.seat)?
+            .instance
+            .as_str()
+    ))?;
+    let mut physical = PhysicalRuntime::new(
+        Registration {
+            descriptor: &KIRO_DESCRIPTOR,
+            hooks: &hooks,
+            controls: interaction::CONTROLS,
+        },
+        backend::settings(&backend.binding),
+        operation.clone(),
+        &clock,
+    )?;
+    physical.evidence = backend::policy_evidence(&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)
+        || !matches!(sample.server.outcome, ProbeOutcome::Observed(ref server) if server.initialize_response_written && server.tools_list_response_written)
+    {
+        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());
+        }
+    };
+    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);
+    let mut bootstrap = OutboxBootstrap::new(ContractStore::open(
+        &backend.binding.transport_root,
+        backend.binding.scope.clone(),
+        &backend.binding.endpoint,
+    )?);
+    physical.bootstrap = Some(&mut bootstrap);
+    let sample = physical.readiness(seat)?;
+    let authorization = DeliveryAuthorization {
+        allow_first_business_bootstrap: false,
+        require_server_handshake: true,
+        channel: Channel::Tmux,
+        policy_sha256: interaction::POLICY,
+    };
+    let _ = team_agent_contract::orchestration::supervisor::tick(
+        &mut backend.store,
+        &seat.identity,
+        &sample,
+        &authorization,
+        &mut physical,
+    )?;
+    Ok(())
+}
+
+pub fn tick(workspace: &Path, state: &mut Value) -> Result<(), BackendError> {
+    if !framework::has_contract(state) {
+        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))
+        .map(|(id, _)| id.clone())
+        .collect();
+    let mut failure = None;
+    for id in ids {
+        let Some(seat) = backend.store.seat(&SeatId::new(&id)?)? else {
+            continue;
+        };
+        if let Err(error) = deliver_one(&mut backend, &seat) {
+            failure = Some(error);
+        }
+        if let Some(agent) = state
+            .get_mut("agents")
+            .and_then(|agents| agents.get_mut(&id))
+        {
+            match framework::project_seat(workspace, &team, &id) {
+                Ok(projected) => *agent = projected,
+                Err(error) => failure = Some(error),
+            }
+        }
+    }
+    // One blocked seat must not prevent already committed results from reaching
+    // the shared framework task-finalization/leader-presentation path.
+    forward::drain(&backend.binding.framework(), &mut backend.store, 32)?;
+    match failure {
+        Some(error) => Err(error),
+        None => Ok(()),
+    }
+}

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

@@ -0,0 +1,30 @@
+//! The sole new-runtime provider registration. 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;
+
+const DESCRIPTORS: &[&ProviderDescriptor] = &[&KIRO_DESCRIPTOR];
+
+pub(crate) fn descriptors() -> &'static [&'static ProviderDescriptor] {
+    DESCRIPTORS
+}
+
+pub fn descriptor(key: &str) -> Option<&'static ProviderDescriptor> {
+    DESCRIPTORS.iter().copied().find(|descriptor| {
+        descriptor.identity.id == key || descriptor.identity.aliases.contains(&key)
+    })
+}
+
+/// Recognize a misspelled/case-modified contract declaration so it can fail
+/// explicitly instead of accidentally selecting a legacy default provider.
+pub fn recognizes(key: &str) -> bool {
+    let key = key.trim();
+    DESCRIPTORS.iter().any(|descriptor| {
+        descriptor.identity.id.eq_ignore_ascii_case(key)
+            || descriptor
+                .identity
+                .aliases
+                .iter()
+                .any(|alias| alias.eq_ignore_ascii_case(key))
+    })
+}

package/crates/team-agent/src/coordinator/tick.rs

@@ -359,6 +359,19 @@ impl Coordinator {
         let event_log = EventLog::new(self.workspace.as_path());
         increment_coordinator_tick_iteration_count(&self.workspace);
 
+        #[cfg(unix)]
+        if let Err(error) =
+            crate::contract_runtime::pump::tick(self.workspace.as_path(), &mut state)
+        {
+            let _ = event_log.write(
+                "contract.tick.failed",
+                serde_json::json!({"error":error.to_string()}),
+            );
+        }
+        #[cfg(unix)]
+        let contract_only = crate::contract_runtime::framework::only_contract(&state);
+        #[cfg(not(unix))]
+        let contract_only = false;
         self.record_step(TickStepGroup::SessionGate, "tmux_session_gate");
         if let Some(session_name) = state
             .get("session_name")
@@ -367,7 +380,7 @@ impl Coordinator {
             .map(str::to_owned)
         {
             let session = crate::transport::SessionName::new(&session_name);
-            if !self.transport.has_session(&session)? {
+            if !contract_only && !self.transport.has_session(&session)? {
                 event_log.write(
                     "coordinator.session_missing",
                     serde_json::json!({"session": session_name}),
@@ -564,13 +577,14 @@ impl Coordinator {
                 // Keep the sampled topology guard, but commit only this tick's
                 // observations onto latest so task/note writers cannot be lost.
                 let team_key = crate::state::projection::team_state_key(&state);
-                crate::state::repository::StateRepository::new(self.workspace.as_path()).commit_observations(
-                    crate::state::repository::StateWriteIntent::CoordinatorTick {
-                        team_key: team_key.as_str(),
-                    },
-                    &before_observation,
-                    &state,
-                )
+                crate::state::repository::StateRepository::new(self.workspace.as_path())
+                    .commit_observations(
+                        crate::state::repository::StateWriteIntent::CoordinatorTick {
+                            team_key: team_key.as_str(),
+                        },
+                        &before_observation,
+                        &state,
+                    )
             }
         };
         if saved.is_err() {
@@ -1876,6 +1890,10 @@ fn tick_has_work_obligation(store: &crate::message_store::MessageStore) -> bool
 }
 
 fn agent_probe_base_eligible(agent: &Value) -> bool {
+    #[cfg(unix)]
+    if crate::contract_runtime::framework::is_contract(agent) {
+        return false;
+    }
     let status = agent.get("status").and_then(Value::as_str);
     !matches!(
         status,

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

@@ -81,6 +81,7 @@ pub mod incident;
 pub mod lease;
 pub mod owner_bind;
 pub mod provider_attribution;
+pub mod prompt;
 pub mod rediscover;
 pub mod registry;
 pub mod start;