refactor(runtime): read components, profile capabilities and hook contexts from explicit contexts (#7801)

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

@@ -141,8 +141,8 @@ pub(crate) async fn run_channel_turn_via_graph(
         "[channel:graph] routing channel turn through tinyagents harness"
     );
     let turn_origin = origin.clone();
-    let mut run_context =
-        crate::agent::tinyagents::host::OpenHumanRunContext::new().with_core(dispatch.into_core());
+    let mut run_context = crate::agent::tinyagents::host::OpenHumanRunContext::new()
+        .with_core(dispatch.core().cloned());
     run_context.origin = origin;
     run_context.approval = approval;
     run_context.memory_identity = Some(memory_identity);
@@ -192,7 +192,7 @@ pub(crate) async fn run_channel_turn_via_graph(
         defer_turn_completed_to_caller: false,
     }
     .run();
-    let outcome = match (turn_origin, crate::core::runtime::CoreContext::current()) {
+    let outcome = match (turn_origin, dispatch.into_core()) {
         (Some(origin), Some(context)) => {
             crate::core::runtime::CoreContext::scope_with_turn_origin(
                 context,

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

@@ -309,23 +309,27 @@ pub fn embedder_tool_hooks_in(ctx: &crate::core::runtime::DispatchCtx) -> Vec<Ar
 mod tests;
 
 /// Fire all hooks in parallel, logging errors without blocking the caller.
-pub fn fire_hooks(hooks: &[Arc<dyn PostTurnHook>], ctx: TurnContext) {
+pub fn fire_hooks(
+    hooks: &[Arc<dyn PostTurnHook>],
+    dispatch: &crate::core::runtime::DispatchCtx,
+    ctx: TurnContext,
+) {
     log::debug!(
         "[learning] dispatching {} post-turn hook(s) (tool_calls={}, response_chars={})",
         hooks.len(),
         ctx.tool_calls.len(),
         ctx.assistant_response.chars().count()
     );
-    // Capture the ambient CoreContext before detaching: a bare `tokio::spawn`
+    // Take the caller's CoreContext before detaching: a bare `tokio::spawn`
     // does not inherit the `CURRENT_CONTEXT` task-local, so under a scoped
     // multi-tenant dispatch a detached hook would fall back to the process
     // default context — and anything context-derived inside the hook (for
     // example a workspace-scoped store) would read and
     // write another tenant's workspace. Re-entering the scope inside the task
     // keeps the hook on the dispatch it belongs to; when there is no scoped
-    // context (the desktop's single-tenant path), `current()` already answers
-    // the process default and re-scoping it is a no-op.
-    let core_ctx = crate::core::runtime::context::CoreContext::current();
+    // context (the desktop's single-tenant path), the process default is
+    // already what the hook reads and re-scoping it is a no-op.
+    let core_ctx = dispatch.core().cloned();
     for (idx, hook) in hooks.iter().enumerate() {
         let hook = Arc::clone(hook);
         let ctx = ctx.clone();

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

@@ -111,17 +111,17 @@ async fn fire_hooks_accepts_empty_hook_list() {
         iteration_count: 1,
     };
     // Should not panic
-    fire_hooks(&[], ctx);
+    fire_hooks(&[], &crate::core::runtime::DispatchCtx::unbound(), ctx);
 }
 
 // ── Detached hooks keep the dispatch's CoreContext ────────────────────────────
 
-/// A detached hook task must observe the same ambient [`CoreContext`] as the
-/// dispatch that fired it. A bare `tokio::spawn` loses the `CURRENT_CONTEXT`
+/// A detached hook task must observe the same [`CoreContext`] as the dispatch
+/// that fired it, handed over explicitly. A bare `tokio::spawn` loses the `CURRENT_CONTEXT`
 /// task-local — under a scoped multi-tenant dispatch that meant the hook fell
 /// back to the process default context, and any context-derived work behind
 /// it read and wrote another tenant's workspace. `fire_hooks` now re-enters
-/// the captured scope inside the spawned task; this pins that.
+/// the context it was given inside the spawned task; this pins that.
 #[tokio::test]
 async fn fired_hooks_observe_the_firing_dispatchs_core_context() {
     use crate::core::runtime::context::CoreContext;
@@ -164,10 +164,13 @@ async fn fired_hooks_observe_the_firing_dispatchs_core_context() {
         iteration_count: 0,
     };
 
-    CoreContext::scope(std::sync::Arc::clone(&tenant_ctx), async {
-        fire_hooks(&[probe], turn);
-    })
-    .await;
+    // The explicit context is what the hook runs under; no task scope is
+    // entered around the call.
+    fire_hooks(
+        &[probe],
+        &crate::core::runtime::DispatchCtx::new(std::sync::Arc::clone(&tenant_ctx)),
+        turn,
+    );
 
     let seen = tokio::time::timeout(std::time::Duration::from_secs(5), rx)
         .await

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

@@ -27,6 +27,7 @@
 //! `TrustedAutomation { Cron }` and a workflow node under its workflow
 //! origin. Resolving an agent does not change who is asking.
 
+use crate::core::runtime::DispatchCtx;
 use std::sync::{Arc, LazyLock, PoisonError, RwLock};
 
 use crate::agent::harness::host_definition::AgentDefinition;
@@ -70,7 +71,11 @@ impl HostAgent {
             "[host_agents] building session for host agent"
         );
         let mut session = CoreContext::sync_scope(Arc::clone(&self.context), || {
-            if crate::profiles::capabilities::ProfileCapabilities::current().is_some() {
+            if crate::profiles::capabilities::ProfileCapabilities::in_ctx(&DispatchCtx::new(
+                Arc::clone(&self.context),
+            ))
+            .is_some()
+            {
                 return OpenHumanSessionHost::from_config_host_only(
                     config,
                     &self.definition,

crates/openhuman-core/src/agent/session_host/builder/factory.rs

@@ -8,6 +8,7 @@ use crate::agent::host_runtime;
 use crate::agent::prompts::SystemPromptBuilder;
 use crate::agent::session_host::types::OpenHumanSessionHost;
 use crate::config::Config;
+use crate::core::runtime::DispatchCtx;
 use crate::security::SecurityPolicy;
 use crate::tools;
 use anyhow::Result;
@@ -78,9 +79,8 @@ impl OpenHumanSessionHost {
     /// Tauri web channel (see `channels::provider::web::build_session_agent`).
     pub fn from_config_for_agent(config: &Config, agent_id: &str) -> Result<Self> {
         // A hosted profile never receives the ordinary config-derived belt.
-        // Its operator-selected factory carries registration and permission
-        // boundaries into the same session builder, under this profile scope.
-        if crate::profiles::capabilities::ProfileCapabilities::current().is_some() {
+        let ambient = DispatchCtx::ambient();
+        if crate::profiles::capabilities::ProfileCapabilities::in_ctx(&ambient).is_some() {
             return Self::from_config_for_agent_session(config, agent_id, None);
         }
         let target_def = resolve_target_definition(config, agent_id)?;

crates/openhuman-core/src/agent/session_host/builder/profile_factory.rs

@@ -2,6 +2,7 @@
 
 use crate::agent::OpenHumanSessionHost;
 use crate::config::Config;
+use crate::core::runtime::DispatchCtx;
 
 impl OpenHumanSessionHost {
     /// Build a config-routed agent with its caller's exact conversation key.
@@ -15,7 +16,9 @@ impl OpenHumanSessionHost {
         agent_id: &str,
         session_id: Option<&str>,
     ) -> anyhow::Result<Self> {
-        if let Some(capabilities) = crate::profiles::capabilities::ProfileCapabilities::current() {
+        if let Some(capabilities) =
+            crate::profiles::capabilities::ProfileCapabilities::in_ctx(&DispatchCtx::ambient())
+        {
             let mut definition = super::factory::resolve_target_definition(config, agent_id)?
                 .ok_or_else(|| anyhow::anyhow!("profile agent definition is unavailable"))?;
             capabilities.apply_system_prompt(&mut definition);

crates/openhuman-core/src/agent/session_host/runtime_session/memory_ingest.rs

@@ -128,7 +128,10 @@ impl OpenHumanTurnPrelude {
         if self.omit_memory_context {
             identity.recall = false;
         }
-        let profile_context = capture_profile_context(crate::profiles::host::host().as_deref());
+        let profile_context = capture_profile_context(
+            &self.dispatch_ctx(),
+            crate::profiles::host::host().as_deref(),
+        );
         if matches!(profile_context, ProfileMemoryContext::Denied) {
             return None;
         }
@@ -237,8 +240,11 @@ impl OpenHumanTurnPrelude {
 
 // Resolve the profile owner at preparation; a canonical commit may run after
 // the immutable turn-origin scope has ended.
-fn capture_profile_context(host: Option<&crate::profiles::ProfileHost>) -> ProfileMemoryContext {
-    let Some(context) = crate::core::runtime::CoreContext::scoped() else {
+fn capture_profile_context(
+    ctx: &DispatchCtx,
+    host: Option<&crate::profiles::ProfileHost>,
+) -> ProfileMemoryContext {
+    let Some(context) = ctx.core().cloned() else {
         return if crate::core::runtime::is_saas() {
             ProfileMemoryContext::Denied
         } else {

crates/openhuman-core/src/agent/session_host/runtime_session/memory_ingest_tests.rs

@@ -90,10 +90,8 @@ async fn deferred_memory_commit_survives_the_turn_scope_without_pinning_the_prof
     let id = ProfileId::parse("deferred-memory").unwrap();
     host.provision(&id).await.unwrap();
     let profile = host.open(&id).await.unwrap();
-    let captured = CoreContext::scope_with_turn_origin(profile.context().clone(), None, async {
-        capture_profile_context(Some(&host))
-    })
-    .await;
+    let captured =
+        capture_profile_context(&DispatchCtx::new(profile.context().clone()), Some(&host));
     // The entire temporary turn context is gone before this callback is polled.
     let config = profile.config.clone();
     let work = async {
@@ -161,8 +159,7 @@ async fn missing_profile_owner_refuses_deferred_memory_instead_of_running_unscop
         )
         .profile("missing-owner"),
     );
-    let captured =
-        CoreContext::scope(missing, async { capture_profile_context(Some(&host)) }).await;
+    let captured = capture_profile_context(&DispatchCtx::new(missing), Some(&host));
     deferred_memory_work(captured, async {
         panic!("a failed profile owner capture must not run under the configured external engine")
     })
@@ -183,14 +180,14 @@ async fn failed_profile_capture_is_denied_but_ordinary_desktop_work_still_runs()
             )
             .profile(id),
         );
-        let captured = CoreContext::scope(profile, async { capture_profile_context(None) }).await;
+        let captured = capture_profile_context(&DispatchCtx::new(profile), None);
         assert!(matches!(captured, ProfileMemoryContext::Denied));
         deferred_memory_work(captured, async {
             panic!("a profile without its host cannot resolve an external engine")
         })
         .await;
     }
-    let captured = CoreContext::scope(operator, async { capture_profile_context(None) }).await;
+    let captured = capture_profile_context(&DispatchCtx::new(operator), None);
     assert!(matches!(captured, ProfileMemoryContext::NonProfile));
     let mut ran = false;
     deferred_memory_work(captured, async {

crates/openhuman-core/src/agent/session_host/runtime_session/post_commit.rs

@@ -132,6 +132,8 @@ pub(super) async fn finalize_committed_turn(
     receipt: tinyagents_runtime::CommitReceipt<crate::agent::tinyagents::host::OpenHumanRunContext>,
 ) {
     let commit_started = std::time::Instant::now();
+    // The turn's own context, taken before the receipt is dropped.
+    let dispatch = receipt.options.context.dispatch_ctx();
     let output = receipt.outcome.output.clone().unwrap_or_default();
     // Skips compaction checkpoints (user-role, not the user's words).
     let input = tinyagents_harness::summarization::last_user_message(&receipt.outcome.history)
@@ -235,6 +237,7 @@ pub(super) async fn finalize_committed_turn(
     }
     crate::agent::hooks::fire_hooks(
         post_turn_hooks,
+        &dispatch,
         crate::agent::hooks::TurnContext {
             user_message: input,
             assistant_response: output,

crates/openhuman-core/src/agent/tinyagents/host/learning_sink.rs

@@ -112,7 +112,12 @@ impl LearningSink for OpenHumanLearningSink {
             self.hooks.len()
         );
 
-        hooks::fire_hooks(&self.hooks, Self::turn_context_from(summary));
+        // Transitional (#7801): the learning sink is built without a context.
+        hooks::fire_hooks(
+            &self.hooks,
+            &crate::core::runtime::DispatchCtx::ambient(),
+            Self::turn_context_from(summary),
+        );
         Ok(())
     }
 }

crates/openhuman-core/src/agent/tinyagents/tool_registration.rs

@@ -107,7 +107,10 @@ impl ToolExecScope for TurnOriginScope {
             .and_then(|extension| extension.downcast_ref::<ToolExecutionContext>())
             .and_then(|context| context.state::<HostOperationContext>())
             .and_then(|context| context.origin.clone());
-        match (origin, CoreContext::current()) {
+        match (
+            origin,
+            super::host::run_context::dispatch_ctx_for_tool(context).into_core(),
+        ) {
             (Some(origin), Some(core_context)) => Box::pin(CoreContext::scope_with_turn_origin(
                 core_context,
                 Some(origin),

crates/openhuman-core/src/channels/providers/relay/ops.rs

@@ -247,7 +247,7 @@ pub(crate) async fn run_relay_turn(
     let mut runtime_message = crate::channels::runtime::RuntimeChannelMessage::from(message);
     runtime_message.prepared_inbound = Some(prepared);
     let turn = process_channel_runtime_message(ctx, runtime_message);
-    if let Some(context) = crate::core::runtime::CoreContext::scoped() {
+    if let Some(context) = dispatch_ctx.core() {
         crate::core::runtime::CoreContext::scope(
             context.derive_channel_turn(Some(thread_id.clone()), None),
             Box::pin(turn),

crates/openhuman-core/src/channels/runtime/dispatch/host_agent/mod.rs

@@ -24,6 +24,7 @@ use crate::channels::{ChannelSendExt, SendMessage};
 use crate::config::Config;
 use crate::core::bus::BUS;
 use crate::core::events::DomainEvent;
+use crate::core::runtime::DispatchCtx;
 use tinychannels_bus as traits;
 
 pub(crate) mod posture;
@@ -53,9 +54,13 @@ pub(crate) fn bound_agent_id<'a>(config: &'a Config, channel: &str) -> Option<&'
 
 /// Resolve `channel`'s binding against the installed host agents.
 pub(crate) fn route(ctx: &ChannelRuntimeContext, channel: &str) -> HostRoute {
-    if let Some(capabilities) = crate::profiles::capabilities::ProfileCapabilities::current() {
+    // Transitional (#7801): the channel runtime context carries no core yet.
+    let dispatch = DispatchCtx::ambient();
+    if let Some(capabilities) =
+        crate::profiles::capabilities::ProfileCapabilities::in_ctx(&dispatch)
+    {
         if let (Some(context), Some(config), Some(definitions)) = (
-            crate::core::runtime::CoreContext::scoped(),
+            dispatch.core().cloned(),
             ctx.config.as_ref(),
             crate::agent::harness::host_definition::AgentDefinitionRegistry::current(),
         ) {

crates/openhuman-core/src/channels/runtime/startup/turn_parts.rs

@@ -12,6 +12,7 @@ use crate::agent::host_runtime;
 use crate::channels::context::ChannelRuntimeContext;
 use crate::channels::system_prompt::{ChannelPromptInputs, ChannelSystemPrompt};
 use crate::config::Config;
+use crate::core::runtime::DispatchCtx;
 use crate::inference::provider;
 use crate::security::SecurityPolicy;
 use crate::tools;
@@ -141,7 +142,8 @@ pub(crate) fn build_channel_turn_parts(
         config.workspace_dir.clone(),
     )?;
     let workspace = config.workspace_dir.clone();
-    let capabilities = crate::profiles::capabilities::ProfileCapabilities::current();
+    let capabilities =
+        crate::profiles::capabilities::ProfileCapabilities::in_ctx(&DispatchCtx::ambient());
     let tools_registry = Arc::new(if capabilities.is_some() {
         // The profile host route builds the selected belt once with the exact
         // durable thread. No second, unnamed factory invocation is needed here.

crates/openhuman-core/src/config/ops/loader/load.rs

@@ -37,16 +37,7 @@ pub async fn load_config_with_timeout() -> Result<Config, String> {
     // read the task's ambient context. SaaS reads only the task's own scope, as
     // `Config::load_or_init` does, so a task that lost its user scope fails
     // rather than getting the operator's.
-    let ambient = if crate::core::runtime::is_saas() {
-        crate::core::runtime::CoreContext::scoped()
-    } else {
-        crate::core::runtime::CoreContext::current()
-    };
-    let ctx = ambient.map_or_else(
-        crate::core::runtime::DispatchCtx::unbound,
-        crate::core::runtime::DispatchCtx::new,
-    );
-    load_config_in(&ctx).await
+    load_config_in(&crate::core::runtime::DispatchCtx::ambient()).await
 }
 
 /// [`load_config_with_timeout`] for the context the caller was handed.

crates/openhuman-core/src/config/ops/search.rs

@@ -289,13 +289,14 @@ pub fn apply_search_patch(config: &mut Config, update: SearchSettingsPatch) -> R
 
 /// Validate, save, refresh the module, and return the new settings.
 pub async fn apply_search_settings(
+    ctx: &DispatchCtx,
     config: &mut Config,
     update: SearchSettingsPatch,
 ) -> Result<Outcome<Value>, String> {
     apply_search_patch(config, update)?;
     config.save().await.map_err(|e| e.to_string())?;
     #[cfg(feature = "modules")]
-    crate::modules::search::refresh_loaded(config).await?;
+    crate::modules::search::refresh_loaded(ctx, config).await?;
     tracing::debug!(
         enabled = crate::search::is_active(config),
         providers = ?config.search.enabled_provider_names(),
@@ -315,7 +316,7 @@ pub async fn load_and_apply_search_settings(
     update: SearchSettingsPatch,
 ) -> Result<Outcome<Value>, String> {
     let mut config = ctx.load_config().await?;
-    apply_search_settings(&mut config, update).await
+    apply_search_settings(ctx, &mut config, update).await
 }
 
 /// The settings view: every listed provider's resolved state, the role