refactor: reduce sonar cognitive complexity (NVIDIA#167)

#### Overview

Refactor the functions reported by Sonar for excessive cognitive complexity while preserving runtime behavior. The changes split branch-heavy Rust and Go test logic into focused helpers.

- [x] I confirm this contribution is my own work, or I have the right to submit it under this project's license.
- [x] I searched existing issues and open pull requests, and this does not duplicate existing work.

#### Details

- Extracted plugin editor menu action handling into smaller helpers.
- Extracted CLI session event routing and explicit subagent alias handling.
- Split ATIF agent scope tree construction into focused construction, linking, and sorting helpers.
- Split ATIF test shape assertions into targeted helper assertions.
- Split Go observability and OpenInference tests into setup and assertion helpers.

Validation run:

- `cargo fmt --all`
- `gofmt`
- `cargo clippy --workspace --all-targets -- -D warnings`
- `just test-go`
- `go vet ./...`
- `just test-node`
- `just test-wasm`
- `cargo test -p nemo-relay-cli --bin nemo-relay -- --test-threads=1`

Notes:

- `just test-rust` compiled the affected crates and passed the core/adaptive suites, but hit an existing cwd-sensitive parallel CLI test failure. The failing test passed in isolation and in the serial CLI binary suite listed above.
- `just test-python` is blocked by dependency resolution for `nemo-relay[deepagents]`: the resolver only sees `langchain<=1.3.2` for the Linux split while the existing project requirements ask for `langchain>=1.3.3`.

#### Where should the reviewer start?

Start with `crates/core/src/observability/atif.rs` for the largest decomposition, then `crates/cli/src/session.rs` for the session routing helper extraction.

#### Related Issues: (use one of the action keywords Closes / Fixes / Resolves / Relates to)

- Relates to: none

Authors:
  - Will Killian (https://github.com/willkill07)

Approvers:
  - David Gardner (https://github.com/dagardner-nv)

URL: NVIDIA#167

Author: willkill07

crates/cli/src/plugins.rs

@@ -14,6 +14,7 @@ use console::{Key, Term, style};
 use dialoguer::theme::ColorfulTheme;
 use dialoguer::{Input, Select};
 use nemo_relay::config_editor::{EditorFieldKind, EditorFieldSpec};
+use nemo_relay::plugin::PluginConfig;
 use serde_json::{Value, json};
 
 use crate::config::PluginsEditCommand;
@@ -41,6 +42,12 @@ enum MenuResponse {
     Cancel,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum EditLoopControl {
+    Continue,
+    Finish,
+}
+
 #[derive(Debug)]
 struct MenuItem {
     label: String,
@@ -107,82 +114,152 @@ pub(crate) fn edit(command: PluginsEditCommand) -> Result<(), CliError> {
         if let Some(selected) = menu_response_index(&selection) {
             selected_index = selected;
         }
-        match selection {
-            MenuResponse::Selected(selection) => match actions.get(selection).copied() {
-                Some(MenuAction::ToggleComponent(component_index)) => {
-                    if let Some(component) = components.get_mut(component_index) {
-                        component.toggle_enabled();
-                    }
-                }
-                Some(MenuAction::EditField {
-                    component_index,
-                    field_index,
-                }) => {
-                    if let Some(component) = components.get_mut(component_index)
-                        && let Some(field) = component.fields().get(field_index)
-                    {
-                        edit_component_field(&theme, component, *field)?;
-                    }
-                }
-                Some(MenuAction::Preview) => {
-                    let preview_config = config_with_editable_components(&config, &components)?;
-                    print_preview(&preview_config)?;
-                }
-                Some(MenuAction::Save) => {
-                    store_editable_components(&mut config, &components)?;
-                    validate_config(&config)?;
-                    write_plugin_config(&path, &config)?;
-                    print_save_success(&path);
-                    return Ok(());
-                }
-                Some(MenuAction::Cancel) | None => {
-                    return Err(CliError::Config(
-                        "plugin edit cancelled; no config saved".into(),
-                    ));
-                }
-            },
-            MenuResponse::Shortcut(MenuShortcut::Preview, _) => {
-                let preview_config = config_with_editable_components(&config, &components)?;
-                print_preview(&preview_config)?;
-            }
-            MenuResponse::Shortcut(MenuShortcut::Save, _) => {
-                store_editable_components(&mut config, &components)?;
-                validate_config(&config)?;
-                write_plugin_config(&path, &config)?;
-                print_save_success(&path);
-                return Ok(());
+        if handle_menu_response(
+            &theme,
+            &path,
+            &mut config,
+            &mut components,
+            &actions,
+            selection,
+        )? == EditLoopControl::Finish
+        {
+            return Ok(());
+        }
+    }
+}
+
+fn handle_menu_response(
+    theme: &ColorfulTheme,
+    path: &Path,
+    config: &mut PluginConfig,
+    components: &mut [EditableComponent],
+    actions: &[MenuAction],
+    selection: MenuResponse,
+) -> Result<EditLoopControl, CliError> {
+    match selection {
+        MenuResponse::Selected(selection) => handle_menu_action(
+            theme,
+            path,
+            config,
+            components,
+            actions.get(selection).copied(),
+        ),
+        MenuResponse::Shortcut(MenuShortcut::Preview, _) => {
+            preview_components(config, components)?;
+            Ok(EditLoopControl::Continue)
+        }
+        MenuResponse::Shortcut(MenuShortcut::Save, _) => save_components(path, config, components),
+        MenuResponse::Shortcut(MenuShortcut::Help, _) => {
+            print_editor_help();
+            Ok(EditLoopControl::Continue)
+        }
+        MenuResponse::Shortcut(
+            shortcut @ (MenuShortcut::Reset | MenuShortcut::Clear),
+            selected,
+        ) => handle_reset_or_clear_shortcut(components, actions.get(selected).copied(), shortcut),
+        MenuResponse::Cancel => Err(cancelled_error()),
+    }
+}
+
+fn handle_menu_action(
+    theme: &ColorfulTheme,
+    path: &Path,
+    config: &mut PluginConfig,
+    components: &mut [EditableComponent],
+    action: Option<MenuAction>,
+) -> Result<EditLoopControl, CliError> {
+    match action {
+        Some(MenuAction::ToggleComponent(component_index)) => {
+            if let Some(component) = components.get_mut(component_index) {
+                component.toggle_enabled();
             }
-            MenuResponse::Shortcut(MenuShortcut::Help, _) => print_editor_help(),
-            MenuResponse::Shortcut(
-                shortcut @ (MenuShortcut::Reset | MenuShortcut::Clear),
-                selected,
-            ) => match actions.get(selected).copied() {
-                Some(MenuAction::ToggleComponent(component_index)) => {
-                    if let Some(component) = components.get_mut(component_index) {
-                        apply_component_enablement_shortcut(component, shortcut);
-                    }
-                }
-                Some(MenuAction::EditField {
-                    component_index,
-                    field_index,
-                }) => {
-                    if let Some(component) = components.get_mut(component_index)
-                        && let Some(field) = component.fields().get(field_index)
-                    {
-                        component.reset_field(*field)?;
-                    }
-                }
-                _ => {
-                    println!("  Select a component or editable field to reset or clear.");
-                }
-            },
-            MenuResponse::Cancel => {
-                return Err(CliError::Config(
-                    "plugin edit cancelled; no config saved".into(),
-                ));
+            Ok(EditLoopControl::Continue)
+        }
+        Some(MenuAction::EditField {
+            component_index,
+            field_index,
+        }) => {
+            edit_selected_component_field(theme, components, component_index, field_index)?;
+            Ok(EditLoopControl::Continue)
+        }
+        Some(MenuAction::Preview) => {
+            preview_components(config, components)?;
+            Ok(EditLoopControl::Continue)
+        }
+        Some(MenuAction::Save) => save_components(path, config, components),
+        Some(MenuAction::Cancel) | None => Err(cancelled_error()),
+    }
+}
+
+fn edit_selected_component_field(
+    theme: &ColorfulTheme,
+    components: &mut [EditableComponent],
+    component_index: usize,
+    field_index: usize,
+) -> Result<(), CliError> {
+    if let Some(component) = components.get_mut(component_index)
+        && let Some(field) = component.fields().get(field_index)
+    {
+        edit_component_field(theme, component, *field)?;
+    }
+    Ok(())
+}
+
+fn preview_components(
+    config: &PluginConfig,
+    components: &[EditableComponent],
+) -> Result<(), CliError> {
+    let preview_config = config_with_editable_components(config, components)?;
+    print_preview(&preview_config)
+}
+
+fn save_components(
+    path: &Path,
+    config: &mut PluginConfig,
+    components: &[EditableComponent],
+) -> Result<EditLoopControl, CliError> {
+    store_editable_components(config, components)?;
+    validate_config(config)?;
+    write_plugin_config(path, config)?;
+    print_save_success(path);
+    Ok(EditLoopControl::Finish)
+}
+
+fn handle_reset_or_clear_shortcut(
+    components: &mut [EditableComponent],
+    action: Option<MenuAction>,
+    shortcut: MenuShortcut,
+) -> Result<EditLoopControl, CliError> {
+    match action {
+        Some(MenuAction::ToggleComponent(component_index)) => {
+            if let Some(component) = components.get_mut(component_index) {
+                apply_component_enablement_shortcut(component, shortcut);
             }
         }
+        Some(MenuAction::EditField {
+            component_index,
+            field_index,
+        }) => reset_selected_component_field(components, component_index, field_index)?,
+        _ => println!("  Select a component or editable field to reset or clear."),
     }
+    Ok(EditLoopControl::Continue)
+}
+
+fn reset_selected_component_field(
+    components: &mut [EditableComponent],
+    component_index: usize,
+    field_index: usize,
+) -> Result<(), CliError> {
+    if let Some(component) = components.get_mut(component_index)
+        && let Some(field) = component.fields().get(field_index)
+    {
+        component.reset_field(*field)?;
+    }
+    Ok(())
+}
+
+fn cancelled_error() -> CliError {
+    CliError::Config("plugin edit cancelled; no config saved".into())
 }
 
 fn edit_component_field(

crates/cli/src/session.rs

@@ -277,27 +277,11 @@ impl SessionManager {
                 continue;
             }
 
-            let mut event = alignment_state.route_event(event);
-            let explicit_subagent_alias = alignment::explicit_subagent_alias(&mut event);
-            let session_id = event.session_id().to_string();
-            let is_agent_started = matches!(&event, NormalizedEvent::AgentStarted(_));
-            if event.is_terminal() && !sessions.contains_key(&session_id) {
+            let Some((event, session_id, is_agent_started)) =
+                route_event_for_session(event, &mut sessions, &mut alignment_state)
+            else {
                 continue;
-            }
-            if let Some((child_session_id, alias)) = explicit_subagent_alias {
-                if sessions
-                    .get(&child_session_id)
-                    .is_none_or(|session| session.can_reparent_as_subagent_alias())
-                {
-                    sessions.remove(&child_session_id);
-                    alignment_state.insert_alias(child_session_id, alias);
-                    alignment_state.align_explicit_subagent_end(&mut event);
-                } else {
-                    continue;
-                }
-            } else {
-                alignment_state.align_explicit_subagent_end(&mut event);
-            }
+            };
             let event_kind = event_agent_kind(&event);
             let should_remove_session = apply_event_to_session(
                 &mut sessions,
@@ -756,6 +740,53 @@ async fn close_idle_sessions_from_parts(
     first_error.map_or(Ok(closed_turns), Err)
 }
 
+fn route_event_for_session(
+    event: NormalizedEvent,
+    sessions: &mut HashMap<String, Session>,
+    alignment_state: &mut SessionAlignmentState,
+) -> Option<(NormalizedEvent, String, bool)> {
+    let mut event = alignment_state.route_event(event);
+    let explicit_subagent_alias = alignment::explicit_subagent_alias(&mut event);
+    let session_id = event.session_id().to_string();
+    let is_agent_started = matches!(&event, NormalizedEvent::AgentStarted(_));
+
+    if event.is_terminal() && !sessions.contains_key(&session_id) {
+        return None;
+    }
+    if !apply_explicit_subagent_alias(
+        &mut event,
+        sessions,
+        alignment_state,
+        explicit_subagent_alias,
+    ) {
+        return None;
+    }
+    Some((event, session_id, is_agent_started))
+}
+
+fn apply_explicit_subagent_alias(
+    event: &mut NormalizedEvent,
+    sessions: &mut HashMap<String, Session>,
+    alignment_state: &mut SessionAlignmentState,
+    explicit_subagent_alias: Option<(String, SessionAlias)>,
+) -> bool {
+    let Some((child_session_id, alias)) = explicit_subagent_alias else {
+        alignment_state.align_explicit_subagent_end(event);
+        return true;
+    };
+
+    if sessions
+        .get(&child_session_id)
+        .is_some_and(|session| !session.can_reparent_as_subagent_alias())
+    {
+        return false;
+    }
+    sessions.remove(&child_session_id);
+    alignment_state.insert_alias(child_session_id, alias);
+    alignment_state.align_explicit_subagent_end(event);
+    true
+}
+
 impl Session {
     // Constructs per-session runtime state without creating a scope yet. The root agent scope is
     // opened lazily on the first event or gateway LLM call so sessions created from hints and pure