@team-agent/installer 0.5.113 → 0.5.114

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

@@ -0,0 +1,229 @@
+//! New-runtime egress into the existing shared framework business APIs. A
+//! forwarding intent is not a legacy physical queue, nor proof of presentation.
+use serde_json::{json, Value};
+use team_agent_contract::contract::{session::CwdIdentity, types::ScopeId};
+use team_agent_contract::host::{digest, digest_hex, process::resolve_cwd};
+use team_agent_contract::orchestration::{forward::*, store::ContractStore, Error};
+
+use crate::messaging::{self, MessageTarget, SendOptions, SendOrigin, TrustedSender};
+use crate::model::ids::{AgentId, TaskId, TeamKey};
+
+/// Created from the selected framework Team, never from MCP tool arguments.
+pub struct FrameworkContext {
+    pub workspace: CwdIdentity,
+    pub team: String,
+    pub native_scope: ScopeId,
+}
+impl FrameworkContext {
+    pub fn route(&self) -> Result<String, Error> {
+        Ok(format!(
+            "framework-{}",
+            digest_hex(digest(&serde_json::to_vec(&(
+                &self.workspace,
+                &self.team,
+                &self.native_scope
+            ))?))
+        ))
+    }
+    fn validate(&self, store: &ContractStore) -> Result<(), Error> {
+        if self.team.trim().is_empty()
+            || self.team.chars().any(char::is_control)
+            || store.scope() != &self.native_scope
+            || resolve_cwd(&self.workspace.path).map_err(|_| Error::Fence)? != self.workspace
+        {
+            return Err(Error::Fence);
+        }
+        let selected = crate::state::selector::resolve_active_team_readonly(
+            &self.workspace.path,
+            Some(&self.team),
+            crate::state::selector::SelectorMode::RuntimeOnly,
+        )
+        .map_err(|_| Error::Fence)?;
+        if selected.team_key != self.team
+            || resolve_cwd(&selected.run_workspace).map_err(|_| Error::Fence)? != self.workspace
+        {
+            return Err(Error::Fence);
+        }
+        Ok(())
+    }
+}
+
+fn framework_result(result_id: &str, source: &str, envelope: &Value) -> Result<Value, Error> {
+    if envelope.get("agent_id").and_then(Value::as_str) != Some(source)
+        || envelope
+            .get("task_id")
+            .and_then(Value::as_str)
+            .is_none_or(|task| task.trim().is_empty())
+    {
+        return Err(Error::Fence);
+    }
+    // K3's compact wire (schema 1 / completed) is not the root business envelope.
+    // Reuse the shared normalizer rather than maintaining a second alias/schema
+    // implementation or claiming that a persisted K3 result was forwarded.
+    let normalized = crate::mcp_server::normalize::normalize_report_envelope(envelope);
+    if normalized.presentation_error.is_some() {
+        return Err(Error::Invalid("result presentation"));
+    }
+    let mut value = serde_json::to_value(normalized)?;
+    value["result_id"] = json!(result_id);
+    Ok(value)
+}
+
+/// Reuses the common root send/result operations. No provider implementation is
+/// selected here; the common per-recipient dispatcher remains authoritative.
+fn forward_one(context: &FrameworkContext, intent: &ForwardIntent) -> (ForwardState, Value) {
+    match &intent.payload {
+        ForwardPayload::Message {
+            message,
+            task,
+            sender,
+            recipient,
+            content,
+            mailbox,
+        } => {
+            if sender != intent.source.seat.as_str() {
+                return (
+                    ForwardState::Refused,
+                    json!({"code":"sender_binding_mismatch"}),
+                );
+            }
+            let mut options = SendOptions {
+                origin: SendOrigin::Mcp,
+                task_id: task.as_ref().map(|task| TaskId::new(task.clone())),
+                route_task_id: false,
+                sender: TrustedSender::from_runtime_identity(AgentId::new(sender)),
+                team: Some(TeamKey::new(&context.team)),
+                message_id: Some(message.as_str().into()),
+                wait_visible: false,
+                block_until_delivered: false,
+                timeout: 2.0,
+                ..Default::default()
+            };
+            if *mailbox {
+                options.presentation.sink = messaging::presentation::PresentationSink::Casefile;
+            }
+            match messaging::send_message(
+                &context.workspace.path,
+                &MessageTarget::Single(recipient.clone()),
+                content,
+                &options,
+            ) {
+                Ok(outcome) => {
+                    let accepted = outcome.message_id.as_deref() == Some(message.as_str())
+                        && matches!(
+                            outcome.status,
+                            messaging::DeliveryStatus::Queued
+                                | messaging::DeliveryStatus::StoredOnly
+                                | messaging::DeliveryStatus::Delivered
+                                | messaging::DeliveryStatus::AlreadyDelivered
+                                | messaging::DeliveryStatus::RetryScheduled
+                                | messaging::DeliveryStatus::FallbackLog
+                        );
+                    let state = if accepted {
+                        ForwardState::Accepted
+                    } else if outcome.message_id.is_none()
+                        && matches!(outcome.status, messaging::DeliveryStatus::Refused)
+                    {
+                        ForwardState::Refused
+                    } else {
+                        ForwardState::Unknown
+                    };
+                    (
+                        state,
+                        json!({"ok":outcome.ok,"message_id":outcome.message_id,
+                        "status":outcome.status,"message_status":outcome.message_status.0,
+                        "reason":outcome.reason,"verification":outcome.verification}),
+                    )
+                }
+                // Error alone is not proof that no destination row was written.
+                Err(_) => (
+                    ForwardState::Unknown,
+                    json!({"code":"framework_send_outcome_unknown"}),
+                ),
+            }
+        }
+        ForwardPayload::Result {
+            result_id,
+            envelope,
+        } => {
+            let envelope = match framework_result(result_id, intent.source.seat.as_str(), envelope)
+            {
+                Ok(envelope) => envelope,
+                Err(_) => {
+                    return (
+                        ForwardState::Refused,
+                        json!({"code":"invalid_result_envelope"}),
+                    )
+                }
+            };
+            match messaging::results::report_result_for_owner_team(
+                &context.workspace.path,
+                &envelope,
+                Some(&context.team),
+            ) {
+                Ok(receipt) => (ForwardState::Accepted, receipt),
+                Err(_) => (
+                    ForwardState::Unknown,
+                    json!({"code":"framework_result_outcome_unknown"}),
+                ),
+            }
+        }
+    }
+}
+
+/// The root coordinator owns this consumer. Claim commits before the delegate
+/// is called, so no K3 transaction is held across root framework locks/writes.
+/// InFlight/Unknown items require explicit exact-ID reconciliation, not replay.
+pub fn drain(
+    context: &FrameworkContext,
+    store: &mut ContractStore,
+    limit: usize,
+) -> Result<usize, Error> {
+    context.validate(store)?;
+    let route = context.route()?;
+    let pending = store.pending_forwards(limit)?;
+    let mut completed = 0;
+    for next in pending {
+        if next.source.scope != context.native_scope {
+            return Err(Error::Fence);
+        }
+        let intent = match store.claim_forward(&next.id) {
+            Ok(intent) => intent,
+            Err(Error::Conflict) => continue,
+            Err(error) => return Err(error),
+        };
+        let (state, receipt) = if intent.route != route {
+            (
+                ForwardState::Refused,
+                json!({"code":"framework_route_changed"}),
+            )
+        } else {
+            // Recheck the selected directory before every external operation.
+            context.validate(store)?;
+            forward_one(context, &intent)
+        };
+        store.finish_forward(&intent.id, state, receipt)?;
+        completed += 1;
+    }
+    Ok(completed)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn compact_native_result_becomes_the_existing_framework_business_schema() {
+        let compact = json!({"schema_version":1,"agent_id":"worker","task_id":"msg-bound","status":"completed","summary":"5535"});
+        let result = framework_result("result-fixed", "worker", &compact).unwrap();
+        assert_eq!(result["schema_version"], "result_envelope_v1");
+        assert_eq!(result["status"], "success");
+        assert_eq!(result["task_id"], "msg-bound");
+        assert_eq!(result["summary"], "5535");
+        assert_eq!(result["result_id"], "result-fixed");
+        for field in ["changes", "tests", "risks", "artifacts", "next_actions"] {
+            assert!(result[field].is_array());
+        }
+        crate::messaging::helpers::validate_result_envelope(&result).unwrap();
+        assert!(framework_result("result-fixed", "other", &compact).is_err());
+    }
+}

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

@@ -0,0 +1,261 @@
+//! Shared-framework seams. A contract seat is never projected as a legacy pane:
+//! its private socket's `%0` must not be interpreted on the workspace tmux server.
+use super::{
+    backend::{self, Backend, BackendError},
+    config,
+};
+use serde_json::{json, Value};
+use std::path::Path;
+use team_agent_contract::contract::types::SeatId;
+use team_agent_contract::host::process::{sample_process, ProcessState};
+use team_agent_contract::orchestration::{
+    operator::OperatorSend,
+    store::{Outcome, SeatStatus},
+};
+
+pub fn is_contract(agent: &Value) -> bool {
+    agent
+        .get("provider")
+        .and_then(Value::as_str)
+        .is_some_and(|provider| super::registry::descriptor(provider).is_some())
+}
+pub fn has_contract(state: &Value) -> bool {
+    state
+        .get("agents")
+        .and_then(Value::as_object)
+        .is_some_and(|agents| agents.values().any(is_contract))
+}
+pub fn only_contract(state: &Value) -> bool {
+    state
+        .get("agents")
+        .and_then(Value::as_object)
+        .is_some_and(|agents| !agents.is_empty() && agents.values().all(is_contract))
+}
+/// Unsupported lifecycle operations must stop before the legacy provider enum
+/// can turn an unknown native seat into its historical Codex fallback.
+pub fn require_legacy_lifecycle(
+    workspace: &Path,
+    team: Option<&str>,
+    agent: Option<&str>,
+    operation: &str,
+) -> Result<(), crate::cli::CliError> {
+    let Ok(selected) = crate::state::selector::resolve_active_team_readonly(
+        workspace,
+        team,
+        crate::state::selector::SelectorMode::RuntimeOnly,
+    ) else {
+        return Ok(());
+    };
+    let selected_native = match agent {
+        Some(id) => selected
+            .state
+            .get("agents")
+            .and_then(|agents| agents.get(id))
+            .is_some_and(is_contract),
+        None => has_contract(&selected.state),
+    };
+    let configured_native = selected
+        .state
+        .get("team_dir")
+        .and_then(Value::as_str)
+        .and_then(|directory| {
+            team_config(
+                &selected.run_workspace,
+                Path::new(directory),
+                &selected.team_key,
+            )
+            .ok()
+            .flatten()
+        })
+        .is_some_and(|config| match agent {
+            Some(id) => config.roles.iter().any(|role| role.id.as_str() == id),
+            None => !config.roles.is_empty(),
+        });
+    if selected_native || configured_native {
+        return Err(crate::cli::CliError::Runtime(format!("contract_capability_unverified: {operation} is not admitted for Kiro; no legacy fallback or fresh replacement was performed")));
+    }
+    Ok(())
+}
+pub fn require_legacy_role(
+    path: Option<&Path>,
+    provider: Option<&str>,
+) -> Result<(), crate::cli::CliError> {
+    let declared = path
+        .and_then(|path| std::fs::read_to_string(path).ok())
+        .and_then(|raw| {
+            crate::compiler::split_front_matter(&raw)
+                .0
+                .get("provider")
+                .and_then(crate::model::yaml::Value::as_str)
+                .map(str::to_owned)
+        });
+    if provider
+        .or(declared.as_deref())
+        .is_some_and(super::registry::recognizes)
+    {
+        return Err(crate::cli::CliError::Runtime("contract_capability_unverified: mutable Kiro role lifecycle is not admitted; use initial quick-start; no role file was changed".into()));
+    }
+    Ok(())
+}
+pub fn team_config(
+    workspace: &Path,
+    directory: &Path,
+    team: &str,
+) -> Result<Option<config::TeamConfig>, config::ConfigError> {
+    config::read_team(&crate::cli::QuickStartArgs {
+        workspace: workspace.into(),
+        agents_dir: directory.into(),
+        name: None,
+        team_id: Some(team.into()),
+        yes: false,
+        json: false,
+        detail: false,
+        backend: Some("tmux".into()),
+    })
+}
+pub fn start_role(
+    workspace: &Path,
+    directory: &Path,
+    team: &str,
+    id: &str,
+) -> Result<(), crate::lifecycle::LifecycleError> {
+    let error = |error: String| crate::lifecycle::LifecycleError::Provider(error);
+    let config = team_config(workspace, directory, team)
+        .map_err(|e| error(e.to_string()))?
+        .ok_or_else(|| error("contract role no longer configured".into()))?;
+    let role = config
+        .roles
+        .iter()
+        .find(|role| role.id.as_str() == id)
+        .ok_or_else(|| error("contract role not found".into()))?;
+    let (_, record) =
+        backend::start(workspace, team, role, &config.members).map_err(|e| error(e.to_string()))?;
+    if record.outcome != Outcome::Committed {
+        return Err(error(format!(
+            "native startup {:?}: {}",
+            record.outcome,
+            record.failure.unwrap_or_default()
+        )));
+    }
+    Ok(())
+}
+
+pub fn project_seat(workspace: &Path, team: &str, id: &str) -> Result<Value, BackendError> {
+    let backend = Backend::open_readonly(workspace, team)?;
+    let seat = backend
+        .store
+        .seat(&SeatId::new(id)?)?
+        .ok_or(BackendError::Metadata)?;
+    let role = backend::read_role(&backend.binding, &seat.identity.seat)?;
+    let alive = seat
+        .physical
+        .as_ref()
+        .is_some_and(|target| sample_process(&target.process) == ProcessState::Alive);
+    let status = if seat.status == SeatStatus::Stopped {
+        "stopped"
+    } else if seat.status != SeatStatus::Unknown && alive {
+        "running"
+    } else {
+        "unknown"
+    };
+    Ok(
+        json!({"agent_id":id,"provider":seat.provider,"status":status,"model":role.model,"effort":role.effort,
+        "contract_prompt_sha256":team_agent_contract::host::digest_hex(role.prompt.sha256),
+        "runtime_family":"contract","contract_scope":seat.identity.scope,"contract_instance":seat.identity.instance,
+        "generation":seat.identity.generation,"owner_team_id":team,"team_key":team,
+        "session_id":seat.session.map(|session| session.native_session),
+        "native_endpoint":seat.endpoint,"native_pane":seat.pane,
+        "pane_id":null,"window":null,"session_name":null,
+        "mcp_binding":"unverified","bootstrap_used":seat.bootstrap_used}),
+    )
+}
+
+pub fn enqueue(
+    workspace: &Path,
+    state: &Value,
+    recipient: &str,
+    content: &str,
+    options: &crate::messaging::SendOptions,
+) -> Result<crate::messaging::DeliveryOutcome, crate::messaging::MessagingError> {
+    use crate::messaging::{DeliveryOutcome, DeliveryStatus, MessagingError};
+    let error = |error: String| MessagingError::Validation(error);
+    let team = crate::state::projection::team_state_key(state);
+    let mut backend = Backend::open(workspace, &team).map_err(|e| error(e.to_string()))?;
+    let request = OperatorSend {
+        recipient: SeatId::new(recipient).map_err(|e| error(e.to_string()))?,
+        content: content.into(),
+        task: options.task_id.as_ref().map(|task| task.as_str().into()),
+        message: options
+            .message_id
+            .clone()
+            .map(team_agent_contract::contract::types::MessageId::new)
+            .transpose()
+            .map_err(|e| error(e.to_string()))?,
+        mailbox: options.presentation.sink
+            == crate::messaging::presentation::PresentationSink::Casefile,
+    };
+    let sender = SeatId::new(options.sender.as_str()).map_err(|e| error(e.to_string()))?;
+    let receipt = backend
+        .store
+        .send_from_framework(&request, &sender)
+        .map_err(|e| error(e.to_string()))?;
+    // Queued is durable admission only. The coordinator consumes this outbox;
+    // CLI send never performs its own paste or repeats an uncertain attempt.
+    Ok(DeliveryOutcome {
+        ok: true,
+        status: if receipt.mailbox {
+            DeliveryStatus::StoredOnly
+        } else {
+            DeliveryStatus::Queued
+        },
+        message_status: crate::messaging::helpers::MessageStatusShadow(
+            if receipt.mailbox {
+                "stored_only"
+            } else {
+                "accepted"
+            }
+            .into(),
+        ),
+        message_id: Some(receipt.message.as_str().into()),
+        verification: Some(
+            json!({"runtime":"contract","task_id":receipt.task,
+            "target":receipt.target,"native_submission":"not_observed"})
+            .to_string(),
+        ),
+        stage: None,
+        reason: None,
+        channel: None,
+        ack_forced_off: false,
+        turn_verification: None,
+    })
+}
+
+pub fn stop_selected(workspace: &Path, state: &Value) -> Result<Vec<Value>, BackendError> {
+    let team = crate::state::projection::team_state_key(state);
+    let mut receipts = Vec::new();
+    if let Some(agents) = state.get("agents").and_then(Value::as_object) {
+        for (id, agent) in agents.iter().filter(|(_, agent)| is_contract(agent)) {
+            let backend = Backend::open(workspace, &team)?;
+            let seat = backend
+                .store
+                .seat(&SeatId::new(id)?)?
+                .ok_or(BackendError::Metadata)?;
+            if seat.status == SeatStatus::Stopped {
+                receipts.push(json!({"agent_id":id,"status":"already_stopped"}));
+                continue;
+            }
+            let _ = agent;
+            let receipt = backend::stop(workspace, &team, &SeatId::new(id)?)?;
+            if receipt.outcome != Outcome::Committed {
+                return Err(BackendError::Shutdown {
+                    operation: receipt.id,
+                    phase: receipt.phase,
+                    outcome: receipt.outcome,
+                    failure: receipt.failure,
+                });
+            }
+            receipts.push(json!({"agent_id":id,"status":"stopped","operation":receipt.id}));
+        }
+    }
+    Ok(receipts)
+}