feat(embed): host many isolated agents in one runtime (#7032)

crates/openhuman-core/src/agent/bus.rs

@@ -272,8 +272,10 @@ async fn handle_agent_run_turn(req: AgentTurnRequest) -> Result<AgentTurnRespons
     // the bus without bootstrapping definitions).
     let sandbox_mode = target_agent_id
         .as_deref()
-        .and_then(|id| AgentDefinitionRegistry::global().and_then(|reg| reg.get(id)))
-        .map(|def| def.sandbox_mode)
+        .and_then(|id| {
+            AgentDefinitionRegistry::current()
+                .and_then(|reg| reg.get(id).map(|def| def.sandbox_mode))
+        })
         .unwrap_or(SandboxMode::None);
 
     // Scope the caller-supplied origin around the tool loop so

crates/openhuman-core/src/agent/debug/mod.rs

@@ -119,7 +119,7 @@ pub async fn dump_all_agent_prompts(
     AgentDefinitionRegistry::init_global(&config.workspace_dir)
         .context("initialising AgentDefinitionRegistry for prompt dump")?;
 
-    let registry = AgentDefinitionRegistry::global()
+    let registry = AgentDefinitionRegistry::current()
         .ok_or_else(|| anyhow!("AgentDefinitionRegistry missing after init"))?;
 
     let ids: Vec<String> = registry

crates/openhuman-core/src/agent/harness/builtin_definitions.rs

@@ -80,6 +80,7 @@ pub(crate) fn test_main_def() -> AgentDefinition {
         ],
         delegate_name: None,
         agent_tier: AgentTier::Chat,
+        searches_connected_mcp: false,
         source: DefinitionSource::Builtin,
         graph: Default::default(),
     }
@@ -122,6 +123,7 @@ pub(crate) fn test_inherit_echo_def() -> AgentDefinition {
         subagents: vec![],
         delegate_name: None,
         agent_tier: crate::agent::harness::definition::AgentTier::Worker,
+        searches_connected_mcp: false,
         source: DefinitionSource::Builtin,
         graph: Default::default(),
     }
@@ -160,6 +162,7 @@ pub(crate) fn test_inherit_parallel_worker_def() -> AgentDefinition {
         subagents: vec![],
         delegate_name: None,
         agent_tier: crate::agent::harness::definition::AgentTier::Worker,
+        searches_connected_mcp: false,
         source: DefinitionSource::Builtin,
         graph: Default::default(),
     }

crates/openhuman-core/src/agent/harness/definition/agent_definition.rs

@@ -233,6 +233,12 @@ pub struct AgentDefinition {
     #[serde(default)]
     pub agent_tier: AgentTier,
 
+    /// Whether this agent's turns can search and call the tools of every
+    /// connected MCP server (deferred, through `tool_search`). Set for the
+    /// user-facing orchestrator; specialists reach MCP only through it.
+    #[serde(default)]
+    pub searches_connected_mcp: bool,
+
     // ── source bookkeeping ──────────────────────────────────────────────
     /// Tracks where the definition was loaded from (Builtin vs. File).
     #[serde(skip)]

crates/openhuman-core/src/agent/harness/definition/registry.rs

@@ -151,4 +151,29 @@ impl AgentDefinitionRegistry {
     pub fn global_arc() -> Option<Arc<Self>> {
         GLOBAL.get().cloned()
     }
+
+    /// The catalogue sub-agent lookups resolve through: the ambient agent
+    /// context's own registry when it carries one, else the process registry.
+    pub fn current() -> Option<Arc<Self>> {
+        crate::core::runtime::CoreContext::current()
+            .and_then(|ctx| ctx.definitions())
+            .or_else(Self::global_arc)
+    }
+
+    /// A copy of this registry with `definitions` added, replacing any
+    /// definition with the same id.
+    pub fn with_definitions(&self, definitions: impl IntoIterator<Item = AgentDefinition>) -> Self {
+        let mut registry = Self::default();
+        for definition in self.list() {
+            registry.insert(definition.clone());
+        }
+        for definition in definitions {
+            registry.insert(definition);
+        }
+        registry
+    }
 }
+
+#[cfg(test)]
+#[path = "registry_tests.rs"]
+mod tests;

crates/openhuman-core/src/agent/harness/definition/registry_tests.rs

@@ -0,0 +1,55 @@
+use super::*;
+use crate::core::runtime::{ContextOverlay, CoreContext, DomainSet};
+
+fn named(id: &str, when: &str) -> AgentDefinition {
+    let mut definition = AgentDefinitionRegistry::builtins_only()
+        .get("orchestrator")
+        .cloned()
+        .expect("built-in orchestrator");
+    definition.id = id.to_string();
+    definition.when_to_use = when.to_string();
+    definition
+}
+
+#[test]
+fn with_definitions_adds_and_replaces_without_touching_the_source() {
+    let base = AgentDefinitionRegistry::builtins_only();
+    let before = base.len();
+    let own = base.with_definitions([
+        named("own-worker", "added"),
+        named("orchestrator", "replaced"),
+    ]);
+    assert_eq!(own.len(), before + 1);
+    assert_eq!(own.get("own-worker").unwrap().when_to_use, "added");
+    assert_eq!(own.get("orchestrator").unwrap().when_to_use, "replaced");
+    assert!(base.get("own-worker").is_none());
+    assert_ne!(base.get("orchestrator").unwrap().when_to_use, "replaced");
+}
+
+#[tokio::test]
+async fn current_follows_the_agent_context_and_falls_back_to_the_process() {
+    let own = Arc::new(
+        AgentDefinitionRegistry::builtins_only().with_definitions([named("ctx-only", "mine")]),
+    );
+    let parent = CoreContext::for_test(DomainSet::full(), Some(std::env::temp_dir()));
+    let agent = parent.derive_with(
+        ContextOverlay::new(
+            crate::config::Config::default(),
+            DomainSet::kernel(),
+            crate::tools::toolpacks::ToolGroups::none(),
+        )
+        .session_agent("catalogue-agent")
+        .definitions(Arc::clone(&own)),
+    );
+
+    let seen = CoreContext::scope(agent, async { AgentDefinitionRegistry::current() })
+        .await
+        .expect("the agent's registry");
+    assert!(Arc::ptr_eq(&seen, &own));
+
+    let outside = CoreContext::scope(parent, async { AgentDefinitionRegistry::current() }).await;
+    assert!(
+        outside.is_none_or(|registry| registry.get("ctx-only").is_none()),
+        "a context without its own catalogue resolves through the process"
+    );
+}

crates/openhuman-core/src/agent/harness/definition_tests.rs

@@ -28,6 +28,7 @@ fn make_def(id: &str) -> AgentDefinition {
         subagents: vec![],
         delegate_name: None,
         agent_tier: crate::agent::harness::definition::AgentTier::Worker,
+        searches_connected_mcp: false,
         source: DefinitionSource::Builtin,
         graph: Default::default(),
     }

crates/openhuman-core/src/agent/library/ops.rs

@@ -13,7 +13,7 @@ pub async fn list_definition_metadata() -> Result<Vec<AgentDefinitionDisplay>, S
         AgentDefinitionRegistry::init_global(&config.workspace_dir)
             .map_err(|e| format!("failed to initialise AgentDefinitionRegistry: {e}"))?;
     }
-    let registry = AgentDefinitionRegistry::global()
+    let registry = AgentDefinitionRegistry::current()
         .ok_or_else(|| "AgentDefinitionRegistry not initialised".to_string())?;
     let definitions = registry
         .list()

crates/openhuman-core/src/agent/library/ops_tests.rs

@@ -34,6 +34,7 @@ fn definition() -> AgentDefinition {
         ],
         delegate_name: None,
         agent_tier: AgentTier::Worker,
+        searches_connected_mcp: false,
         source: DefinitionSource::Builtin,
         graph: Default::default(),
     }

crates/openhuman-core/src/agent/multimodal.rs

@@ -125,7 +125,7 @@ impl TextExtractor for DocumentsTextExtractor {
         use crate::modules::documents;
 
         match tokio::time::timeout(PDF_EXTRACTION_TIMEOUT, async {
-            let config = crate::config::Config::load_or_init()
+            let config = crate::config::ops::load_current_or_init()
                 .await
                 .map_err(|error| format!("config unavailable for pdf extraction: {error}"))?;
             documents::extract_text(&config, bytes)

crates/openhuman-core/src/agent/orchestration/agent_teams/runtime.rs

@@ -179,7 +179,7 @@ pub async fn start_member_run(
     // worker keeps the label the approval gate needs. Inherit-only: no origin
     // in scope means the worker stays unlabelled and fails closed as before.
     let inherited_origin = crate::agent::turn_origin::capture();
-    tokio::spawn(async move {
+    crate::core::runtime::spawn_scoped(async move {
         crate::agent::turn_origin::with_inherited_origin(
             inherited_origin,
             run_member_loop(

crates/openhuman-core/src/agent/orchestration/command_center/schemas.rs

@@ -147,9 +147,11 @@ fn handle_agent_work_control(params: Map<String, Value>) -> ControllerFuture {
 /// Resolve an agent id to its registry display name, if the registry is up and
 /// the agent is known. Returns `None` otherwise (e.g. custom/removed agents).
 fn resolve_display_name(agent_id: &str) -> Option<String> {
-    AgentDefinitionRegistry::global()
-        .and_then(|registry| registry.get(agent_id))
-        .map(|definition| definition.display_name().to_string())
+    AgentDefinitionRegistry::current().and_then(|registry| {
+        registry
+            .get(agent_id)
+            .map(|definition| definition.display_name().to_string())
+    })
 }
 
 fn to_json<T: serde::Serialize>(value: T) -> Result<Value, String> {

crates/openhuman-core/src/agent/orchestration/fleet_tools.rs

@@ -44,7 +44,7 @@ impl FleetToolSet {
 
     /// Resolve the set for `agent_definition_id` from the global registry.
     pub(crate) fn for_parent(agent_definition_id: &str) -> Self {
-        let Some(registry) = AgentDefinitionRegistry::global() else {
+        let Some(registry) = AgentDefinitionRegistry::current() else {
             return Self::all();
         };
         let Some(definition) = registry.get(agent_definition_id) else {

crates/openhuman-core/src/agent/orchestration/ops.rs

@@ -338,9 +338,8 @@ impl AgentOrchestrationSession {
 
         let progress_sink = parent.on_progress.clone();
         if let Some(progress) = progress_sink.clone() {
-            let resolved_display_name = AgentDefinitionRegistry::global()
-                .and_then(|reg| reg.get(&agent_id))
-                .map(|def| def.display_name().to_string());
+            let resolved_display_name = AgentDefinitionRegistry::current()
+                .and_then(|reg| reg.get(&agent_id).map(|def| def.display_name().to_string()));
             let _ = progress
                 .send(AgentProgress::SubagentSpawned {
                     agent_id: agent_id.clone(),
@@ -664,7 +663,7 @@ fn resolve_definition(request: &SpawnAgentRequest) -> Result<AgentDefinition, Or
         return Err(OrchestrationError::InvalidSpawnRequest);
     }
     let registry =
-        AgentDefinitionRegistry::global().ok_or(OrchestrationError::RegistryUnavailable)?;
+        AgentDefinitionRegistry::current().ok_or(OrchestrationError::RegistryUnavailable)?;
     registry
         .get(agent_id)
         .cloned()

crates/openhuman-core/src/agent/orchestration/spawn_parallel_graph/run.rs

@@ -47,7 +47,7 @@ pub(crate) async fn run_spawn_parallel_tasks_with_cancellation_and_workspace(
         max_parallel,
         "[spawn_parallel_agents] validated_parent_context"
     );
-    let registry = match AgentDefinitionRegistry::global() {
+    let registry = match AgentDefinitionRegistry::current() {
         Some(registry) => registry,
         None => {
             tracing::debug!("[spawn_parallel_agents] registry_unavailable");
@@ -62,7 +62,7 @@ pub(crate) async fn run_spawn_parallel_tasks_with_cancellation_and_workspace(
     let progress_sink = parent.on_progress.clone();
     let action_root =
         resolve_spawn_parallel_action_root(parent_workspace_descriptor.as_ref()).await;
-    let definitions = snapshot_agent_definitions(registry);
+    let definitions = snapshot_agent_definitions(&registry);
     if cancel.is_cancelled() {
         return Ok(SpawnParallelGraphOutcome::Cancelled(
             "spawn_parallel_agents cancelled at validate".to_string(),

crates/openhuman-core/src/agent/orchestration/tools/continue_subagent.rs

@@ -372,7 +372,7 @@ impl ContinueSubagentTool {
         }
 
         // Look up the agent definition
-        let registry = match AgentDefinitionRegistry::global() {
+        let registry = match AgentDefinitionRegistry::current() {
             Some(reg) => reg,
             None => {
                 return Ok(ToolResult::error(

crates/openhuman-core/src/agent/orchestration/tools/delegate_graph.rs

@@ -12,7 +12,6 @@
 
 use crate::agent::harness::definition::AgentDefinitionRegistry;
 use crate::agent::orchestration::delegation::run_subagent_delegation_with_parent_context;
-use crate::config::Config;
 use async_trait::async_trait;
 use serde_json::json;
 use std::sync::Arc;
@@ -111,7 +110,7 @@ impl Tool for DelegateGraphTool {
     }
 
     fn parameters_schema(&self) -> serde_json::Value {
-        let agent_ids: Vec<String> = AgentDefinitionRegistry::global()
+        let agent_ids: Vec<String> = AgentDefinitionRegistry::current()
             .map(|reg| reg.list().iter().map(|d| d.id.clone()).collect())
             .unwrap_or_default();
 
@@ -212,7 +211,7 @@ impl DelegateGraphTool {
             .map(|n| (n as usize).min(MAX_MAX_REVISIONS))
             .unwrap_or(DEFAULT_MAX_REVISIONS);
 
-        let registry = match AgentDefinitionRegistry::global() {
+        let registry = match AgentDefinitionRegistry::current() {
             Some(reg) => reg,
             None => {
                 return Ok(ToolResult::error(
@@ -229,7 +228,7 @@ impl DelegateGraphTool {
             }
         };
 
-        let config = match Config::load_or_init().await {
+        let config = match crate::config::ops::load_current_or_init().await {
             Ok(cfg) => Arc::new(cfg),
             Err(e) => {
                 return Ok(ToolResult::error(format!(

crates/openhuman-core/src/agent/orchestration/tools/dispatch.rs

@@ -48,7 +48,7 @@ impl DelegationDispatch {
             // `delegate_graph` is a concrete durable graph tool with its own
             // typed dispatcher, and arbitrary `delegate_*` tools must not be
             // mistaken for an agent target merely because of their spelling.
-            name if AgentDefinitionRegistry::global().is_some_and(|registry| {
+            name if AgentDefinitionRegistry::current().is_some_and(|registry| {
                 registry.list().into_iter().any(|definition| {
                     definition
                         .delegate_name
@@ -102,7 +102,7 @@ impl ToolDispatch<(), crate::agent::tinyagents::host::OpenHumanRunContext> for D
                 .await
             }
             DelegationDispatchKind::Archetype => {
-                let Some(agent_id) = AgentDefinitionRegistry::global().and_then(|registry| {
+                let Some(agent_id) = AgentDefinitionRegistry::current().and_then(|registry| {
                     registry.list().into_iter().find_map(|definition| {
                         let name = definition
                             .delegate_name
@@ -163,7 +163,7 @@ pub(crate) async fn dispatch_subagent_with_live_parent(
     let parent_workspace_descriptor = tool_context
         .and_then(|ctx| ctx.workspace().cloned())
         .or_else(|| run_context.workspace.clone());
-    let registry = match AgentDefinitionRegistry::global() {
+    let registry = match AgentDefinitionRegistry::current() {
         Some(reg) => reg,
         None => {
             return Ok(ToolResult::error(

crates/openhuman-core/src/agent/orchestration/tools/spawn_async_subagent.rs

@@ -168,7 +168,7 @@ impl Tool for SpawnAsyncSubagentTool {
         let agent_ids: Vec<String> = if scoped {
             self.advertised_ids.clone()
         } else {
-            AgentDefinitionRegistry::global()
+            AgentDefinitionRegistry::current()
                 .map(|reg| reg.list().iter().map(|d| d.id.clone()).collect())
                 .unwrap_or_default()
         };

crates/openhuman-core/src/agent/orchestration/tools/spawn_async_subagent_execute.rs

@@ -46,7 +46,7 @@ impl SpawnAsyncSubagentTool {
             }
         };
 
-        let registry = match AgentDefinitionRegistry::global() {
+        let registry = match AgentDefinitionRegistry::current() {
             Some(registry) => registry,
             None => {
                 return Ok(ToolResult::error(
@@ -141,7 +141,7 @@ impl SpawnAsyncSubagentTool {
                 workspace.root.clone()
             })
             .or_else(|| {
-                crate::security::live_policy::current().map(|policy| policy.action_dir.clone())
+                crate::security::live_policy::effective().map(|policy| policy.action_dir.clone())
             });
         let selector = SubagentSessionSelector {
             parent_session: parent_session.clone(),

crates/openhuman-core/src/agent/orchestration/tools/spawn_parallel_agents.rs

@@ -168,7 +168,7 @@ impl Tool for SpawnParallelAgentsTool {
     }
 
     fn parameters_schema(&self) -> serde_json::Value {
-        let agent_ids: Vec<String> = AgentDefinitionRegistry::global()
+        let agent_ids: Vec<String> = AgentDefinitionRegistry::current()
             .map(|reg| reg.list().iter().map(|d| d.id.clone()).collect())
             .unwrap_or_default();
         let agent_id_schema = if agent_ids.is_empty() {

crates/openhuman-core/src/agent/orchestration/tools/spawn_parallel_agents_tests.rs

@@ -170,6 +170,7 @@ fn definition_with_tool_scope(
         subagents: Vec::new(),
         delegate_name: None,
         agent_tier: AgentTier::Worker,
+        searches_connected_mcp: false,
         source: DefinitionSource::Builtin,
         graph: Default::default(),
     }

crates/openhuman-core/src/agent/orchestration/tools/spawn_subagent_parameters.rs

@@ -16,7 +16,7 @@ fn spawn_subagent_parameters_schema() -> serde_json::Value {
     // Build the agent_id enum dynamically from the global registry
     // when it's been initialised. Falls back to a string-with-hint
     // when the registry hasn't been set up yet (e.g. early tests).
-    let agent_ids: Vec<String> = AgentDefinitionRegistry::global()
+    let agent_ids: Vec<String> = AgentDefinitionRegistry::current()
         .map(|reg| reg.list().iter().map(|d| d.id.clone()).collect())
         .unwrap_or_default();
 

crates/openhuman-core/src/agent/orchestration/tools/spawn_subagent_tool_impl.rs

@@ -131,7 +131,7 @@ impl SpawnSubagentTool {
         if prompt.is_empty() {
             return Ok(ToolResult::error("spawn_subagent: `prompt` is required"));
         }
-        let registry = match AgentDefinitionRegistry::global() {
+        let registry = match AgentDefinitionRegistry::current() {
             Some(reg) => reg,
             None => {
                 return Ok(ToolResult::error(