@team-agent/installer 0.5.113 → 0.5.115

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

@@ -0,0 +1,383 @@
+//! Bounded native discovery. Nothing here creates a runtime or claims T2/T3.
+use std::path::{Path, PathBuf};
+
+use team_agent_contract::contract::{hooks::*, plan::CatalogObservation, types::*};
+use team_agent_contract::host::{command::RealCommandRunner, process::resolve_cwd};
+use team_agent_contract::kiro::native as kiro;
+use team_agent_contract::providers::cursor::native as cursor;
+use thiserror::Error;
+
+use super::registry::{self, NativeProvider};
+
+#[derive(Debug, Error)]
+pub enum DiscoveryError {
+    #[error("required executable is unavailable: {0}")]
+    Executable(&'static str),
+    #[error("native discovery failed: {0}")]
+    Host(#[from] team_agent_contract::host::HostError),
+    #[error("native engine probe failed: {0}")]
+    Probe(#[from] kiro::EngineProbeError),
+    #[error("native Cursor launcher probe failed: {0}")]
+    CursorProbe(#[from] cursor::ProbeError),
+    #[error("native discovery contract: {0:?}")]
+    Contract(ContractError),
+    #[error("native model discovery: {0:?}")]
+    Catalog(ReadFailure),
+    #[error("native discovery I/O: {0}")]
+    Io(#[from] std::io::Error),
+}
+
+pub struct Discovery {
+    pub engine: PathBuf,
+    pub native: NativeIdentity,
+    pub catalog: CatalogObservation,
+    pub runtime: Option<cursor::RuntimeInstallation>,
+}
+
+pub fn executable(name: &'static str) -> Result<PathBuf, DiscoveryError> {
+    let path = std::env::var_os("PATH").ok_or(DiscoveryError::Executable(name))?;
+    for directory in std::env::split_paths(&path) {
+        let candidate = directory.join(name);
+        let Ok(metadata) = std::fs::metadata(&candidate) else {
+            continue;
+        };
+        use std::os::unix::fs::PermissionsExt;
+        if metadata.is_file() && metadata.permissions().mode() & 0o111 != 0 {
+            return Ok(candidate.canonicalize()?);
+        }
+    }
+    Err(DiscoveryError::Executable(name))
+}
+
+pub fn discover(provider: &ProviderId, workspace: &Path) -> Result<Discovery, DiscoveryError> {
+    let selected = registry::provider(provider.as_str()).map_err(DiscoveryError::Contract)?;
+    let descriptor = selected.descriptor();
+    let bounds = ReadBounds {
+        deadline: std::time::Duration::from_secs(30),
+        max_output_bytes: 1024 * 1024,
+    };
+    let launcher = executable(descriptor.identity.binary)?;
+    let (engine, native) = match selected {
+        NativeProvider::Kiro => {
+            let home = std::env::var_os("HOME")
+                .map(PathBuf::from)
+                .ok_or(DiscoveryError::Executable("HOME for native installation lookup"))?;
+            let engine = kiro::resolve_helper(&launcher, &home)?;
+            let native = kiro::probe_engine(&engine, &mut RealCommandRunner::default(), bounds)?;
+            (engine, native)
+        }
+        NativeProvider::Cursor => {
+            let engine = cursor::resolve_launcher(&launcher)?;
+            let native = cursor::probe_launcher(&engine, &mut RealCommandRunner::default(), bounds)?;
+            (engine, native)
+        }
+    };
+    let request = CatalogRequest {
+        provider: ProviderId::new(descriptor.identity.id).map_err(DiscoveryError::Contract)?,
+        native: native.clone(),
+        executable: engine.clone(),
+        cwd: resolve_cwd(workspace)?,
+        source: descriptor.model.catalog.require("native catalog source").map_err(DiscoveryError::Contract)?.clone(),
+        bounds,
+    };
+    // H1 does not use these pointers or execute an MCP server. Cursor's
+    // launcher fingerprint authorizes only metadata reads, never worker launch.
+    let adapter = selected.adapter(
+        std::env::current_exe()?.canonicalize()?,
+        Vec::new(),
+        Default::default(),
+    ).map_err(DiscoveryError::Contract)?;
+    let hooks = adapter.hooks();
+    let catalog_hook = hooks.catalog.require("H1 catalog").map_err(DiscoveryError::Contract)?;
+    let catalog = match selected {
+        NativeProvider::Kiro => {
+            let mut host = kiro::CatalogReader::new(request.clone(), RealCommandRunner::default())
+                .map_err(DiscoveryError::Contract)?;
+            catalog_hook.discover(&request, &mut host)
+        }
+        NativeProvider::Cursor => {
+            let mut host = cursor::NativeCatalog::new(request.clone(), RealCommandRunner::default())
+                .map_err(DiscoveryError::Contract)?;
+            catalog_hook.discover(&request, &mut host)
+        }
+    }.map_err(DiscoveryError::Catalog)?;
+    let result = Discovery { engine, native, catalog, runtime: None };
+    validate_catalog(provider, &result).map_err(DiscoveryError::Contract)?;
+    Ok(result)
+}
+
+/// Runtime discovery is separate from public catalog metadata. Cursor explicitly
+/// bridges the same installation's catalog to its proven Node/entry identity.
+pub(super) fn discover_runtime(provider: &ProviderId, workspace: &Path) -> Result<Discovery, DiscoveryError> {
+    let mut discovery = discover(provider, workspace)?;
+    if registry::provider(provider.as_str()).map_err(DiscoveryError::Contract)? == NativeProvider::Cursor {
+        let home = std::env::var_os("HOME").map(PathBuf::from)
+            .ok_or(DiscoveryError::Executable("HOME for native subscription"))?;
+        let runtime = cursor::probe_runtime(&discovery.engine, &home, &mut RealCommandRunner::default(),
+            ReadBounds { deadline: std::time::Duration::from_secs(30), max_output_bytes: 1024 * 1024 })?;
+        discovery.catalog = runtime.bind_catalog(&discovery.catalog).map_err(DiscoveryError::Contract)?;
+        discovery.engine = runtime.engine.clone();
+        discovery.native = runtime.native.clone();
+        discovery.runtime = Some(runtime);
+    }
+    Ok(discovery)
+}
+
+fn validate_catalog(provider: &ProviderId, discovery: &Discovery) -> Result<(), ContractError> {
+    let descriptor = registry::provider(provider.as_str())?.descriptor();
+    if discovery.catalog.provider != *provider
+        || discovery.catalog.native != discovery.native
+        || discovery.catalog.schema != descriptor.model.catalog.require("native catalog source")?.schema
+    {
+        return Err(ContractError::Mismatch("native catalog provider/identity/schema"));
+    }
+    Ok(())
+}
+
+pub fn models(
+    args: &crate::cli::ModelsArgs,
+) -> Result<crate::cli::CmdResult, crate::cli::CliError> {
+    let result = std::env::current_dir()
+        .map_err(DiscoveryError::Io)
+        .and_then(|cwd| {
+            let provider = ProviderId::new(&args.provider).map_err(DiscoveryError::Contract)?;
+            discover(&provider, &cwd)
+        });
+    render_models(args, result)
+}
+
+fn render_models(
+    args: &crate::cli::ModelsArgs,
+    result: Result<Discovery, DiscoveryError>,
+) -> Result<crate::cli::CmdResult, crate::cli::CliError> {
+    use crate::cli::{CmdOutput, CmdResult, ExitCode};
+    use serde_json::json;
+    let result = result.and_then(|discovery| {
+        let provider = ProviderId::new(&args.provider).map_err(DiscoveryError::Contract)?;
+        validate_catalog(&provider, &discovery).map_err(DiscoveryError::Contract)?;
+        Ok(discovery)
+    });
+    let (value, human, exit) = match result {
+        Ok(discovery) => {
+            let query = args.search.as_deref().map(str::to_lowercase);
+            let rows: Vec<_> = discovery.catalog.models.iter()
+                .filter(|model| query.as_ref().is_none_or(|query| model.id.to_lowercase().contains(query)))
+                .map(|model| {
+                    let efforts = match &model.efforts {
+                        Support::Supported(values) => json!({"state":"supported","values":values.iter().map(|value| value.as_str()).collect::<Vec<_>>()}),
+                        Support::Unsupported(reason) => json!({"state":"unsupported","reason":reason.code}),
+                        Support::Unverified(reason) => json!({"state":"unverified","reason":reason.code}),
+                    };
+                    json!({"provider":args.provider,"model_id":model.id,"role_model":model.id,"aliases":[],"efforts":efforts})
+                }).collect();
+            let value = json!({"schema_version":"models.v1","ok":true,"provider":args.provider,
+                "models":rows,"auth":"unknown","auth_basis":"native_catalog_visibility_is_not_authorization",
+                "source":{"schema":discovery.catalog.schema,"executable":discovery.engine,
+                    "version":discovery.native.version,"executable_sha256":team_agent_contract::host::digest_hex(discovery.native.executable_sha256),
+                    "identity_scope":"catalog_only"},
+                "current_role_model":null,"search":args.search});
+            let mut lines = vec![format!("models.v1 | {} native model IDs:", args.provider)];
+            lines.extend(
+                rows.iter()
+                    .filter_map(|row| row["model_id"].as_str())
+                    .map(str::to_owned),
+            );
+            lines.push("Catalog visibility does not prove subscription authorization, runtime model selection, or effort support.".into());
+            (value, lines.join("\n"), ExitCode::Ok)
+        }
+        Err(error) => {
+            let message = error.to_string();
+            let action = "Check the selected native executable and existing subscription; no model fallback or login retry was performed.";
+            (
+                json!({"schema_version":"models.v1","ok":false,"provider":args.provider,"models":[],"auth":"not_ready","error":message,"action":action}),
+                format!("models.v1 | {message}\n{action}"),
+                ExitCode::Error,
+            )
+        }
+    };
+    Ok(CmdResult {
+        output: CmdOutput::Human(if args.json {
+            serde_json::to_string_pretty(&value)?
+        } else {
+            human
+        }),
+        exit,
+        as_json: false,
+        preserve_json_order: true,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::cli::{CmdOutput, ExitCode, ModelsArgs};
+    use team_agent_contract::contract::plan::ModelRecord;
+
+    #[test]
+    fn native_catalog_projection_preserves_ids_without_claiming_auth_or_effort() {
+        let native = NativeIdentity {
+            version: "controlled".into(),
+            harness: "v3".into(),
+            ui: "tui".into(),
+            platform: Platform::Linux,
+            executable_sha256: Digest([1; 32]),
+        };
+        let discovery = Discovery {
+            runtime: None,
+            engine: "/controlled/kiro-cli-chat".into(),
+            native: native.clone(),
+            catalog: CatalogObservation {
+                provider: ProviderId::new("kiro").unwrap(),
+                native,
+                schema: kiro::CHAT_CATALOG_SOURCE.schema.into(),
+                models: vec![ModelRecord {
+                    id: "Exact-Case-ID".into(),
+                    efforts: Support::Unverified(Reason {
+                        code: "not-observed",
+                        message: "No effort evidence",
+                    }),
+                }],
+            },
+        };
+        let args = ModelsArgs {
+            provider: "kiro".into(),
+            search: Some("exact".into()),
+            json: true,
+        };
+        let result = render_models(&args, Ok(discovery)).unwrap();
+        assert_eq!(result.exit, ExitCode::Ok);
+        let CmdOutput::Human(text) = result.output else {
+            panic!("JSON text projection");
+        };
+        let json: serde_json::Value = serde_json::from_str(&text).unwrap();
+        assert_eq!(json["auth"], "unknown");
+        assert_eq!(json["models"][0]["model_id"], "Exact-Case-ID");
+        assert_eq!(json["models"][0]["efforts"]["state"], "unverified");
+        assert_eq!(json["source"]["schema"], kiro::CHAT_CATALOG_SOURCE.schema);
+        assert!(json["current_role_model"].is_null());
+    }
+
+    #[test]
+    fn version_failure_projection_preserves_the_received_version() {
+        let args = ModelsArgs {
+            provider: "kiro".into(),
+            search: None,
+            json: true,
+        };
+        let error = kiro::parse_version(b"kiro-cli-chat 2.29.invalid\n").unwrap_err();
+        let result = render_models(&args, Err(DiscoveryError::Probe(error))).unwrap();
+        assert_eq!(result.exit, ExitCode::Error);
+        let CmdOutput::Human(text) = result.output else {
+            panic!("JSON text projection");
+        };
+        let json: serde_json::Value = serde_json::from_str(&text).unwrap();
+        assert!(json["error"]
+            .as_str()
+            .unwrap()
+            .contains("kiro-cli-chat 2.29.invalid"));
+        assert_eq!(json["models"], serde_json::json!([]));
+    }
+
+    fn cursor_catalog() -> Discovery {
+        let native = NativeIdentity {
+            version: "2026.09.29-a1b2c3".into(),
+            harness: cursor::METADATA_HARNESS.into(),
+            ui: cursor::METADATA_UI.into(),
+            platform: Platform::MacOs,
+            executable_sha256: Digest([2; 32]),
+        };
+        Discovery {
+            runtime: None,
+            engine: "/controlled/cursor-agent".into(),
+            native: native.clone(),
+            catalog: CatalogObservation {
+                provider: ProviderId::new("cursor").unwrap(),
+                native,
+                schema: cursor::CATALOG_SOURCE.schema.into(),
+                models: ["gpt-5.6-luna-xhigh", "gpt-5.6-luna-xhigh-fast", "Other-Exact-ID"]
+                    .into_iter().map(|id| ModelRecord {
+                        id: id.into(),
+                        efforts: Support::Unverified(Reason {
+                            code: "not-observed", message: "Native IDs are not separate effort flags",
+                        }),
+                    }).collect(),
+            },
+        }
+    }
+
+    #[test]
+    fn cursor_catalog_filters_exact_native_family_without_runtime_claims() {
+        let args = ModelsArgs {
+            provider: "cursor".into(), search: Some("GPT-5.6-LUNA-XHIGH".into()), json: true,
+        };
+        let result = render_models(&args, Ok(cursor_catalog())).unwrap();
+        assert_eq!(result.exit, ExitCode::Ok);
+        let CmdOutput::Human(text) = result.output else { panic!("JSON text projection"); };
+        let json: serde_json::Value = serde_json::from_str(&text).unwrap();
+        let ids: Vec<_> = json["models"].as_array().unwrap().iter()
+            .map(|row| row["model_id"].as_str().unwrap()).collect();
+        assert_eq!(ids, ["gpt-5.6-luna-xhigh", "gpt-5.6-luna-xhigh-fast"]);
+        assert_eq!(json["provider"], "cursor");
+        assert_eq!(json["auth"], "unknown");
+        assert_eq!(json["source"]["identity_scope"], "catalog_only");
+        assert_eq!(json["source"]["version"], "2026.09.29-a1b2c3");
+        assert!(json["models"].as_array().unwrap().iter().all(|row|
+            row["efforts"]["state"] == "unverified" && row["aliases"] == serde_json::json!([])));
+        assert!(json["current_role_model"].is_null());
+    }
+
+    #[test]
+    fn mismatched_catalog_provider_native_or_schema_is_not_projected() {
+        let args = ModelsArgs { provider: "cursor".into(), search: None, json: true };
+        for field in ["provider", "native", "schema"] {
+            let mut discovery = cursor_catalog();
+            match field {
+                "provider" => discovery.catalog.provider = ProviderId::new("kiro").unwrap(),
+                "native" => discovery.catalog.native.executable_sha256 = Digest([9; 32]),
+                "schema" => discovery.catalog.schema = kiro::CHAT_CATALOG_SOURCE.schema.into(),
+                _ => unreachable!(),
+            }
+            let result = render_models(&args, Ok(discovery)).unwrap();
+            assert_eq!(result.exit, ExitCode::Error, "{field}");
+            let CmdOutput::Human(text) = result.output else { panic!("JSON text projection"); };
+            let json: serde_json::Value = serde_json::from_str(&text).unwrap();
+            assert_eq!(json["ok"], false);
+            assert_eq!(json["models"], serde_json::json!([]));
+        }
+    }
+
+    #[test]
+    fn cursor_probe_failure_has_no_legacy_or_fixed_model_fallback() {
+        let args = ModelsArgs { provider: "cursor".into(), search: None, json: true };
+        for error in [
+            DiscoveryError::Executable("cursor-agent"),
+            DiscoveryError::CursorProbe(cursor::parse_version(b"Cursor release unknown").unwrap_err()),
+        ] {
+            let result = render_models(&args, Err(error)).unwrap();
+            assert_eq!(result.exit, ExitCode::Error);
+            let CmdOutput::Human(text) = result.output else { panic!("JSON text projection"); };
+            let json: serde_json::Value = serde_json::from_str(&text).unwrap();
+            assert_eq!(json["provider"], "cursor");
+            assert_eq!(json["models"], serde_json::json!([]));
+            assert_eq!(json["ok"], false);
+        }
+    }
+
+    #[test]
+    fn native_discovery_failure_has_no_catalog_or_fallback() {
+        let args = ModelsArgs {
+            provider: "kiro".into(),
+            search: None,
+            json: true,
+        };
+        let result = render_models(&args, Err(DiscoveryError::Executable("kiro-cli"))).unwrap();
+        assert_eq!(result.exit, ExitCode::Error);
+        let CmdOutput::Human(text) = result.output else {
+            panic!("JSON text projection");
+        };
+        let json: serde_json::Value = serde_json::from_str(&text).unwrap();
+        assert_eq!(json["ok"], false);
+        assert_eq!(json["models"], serde_json::json!([]));
+        assert!(json["error"].as_str().unwrap().contains("kiro-cli"));
+    }
+}

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());
+    }
+}