// Swift bridge to Rust kernel
@objc class SoulBridge: NSObject {
    private let kernel: OpaquePointer
    
    init() {
        kernel = soul_kernel_init()
    }
    
    @objc func ask(_ query: String) -> String {
        return String(cString: soul_kernel_ask(kernel, query))
    }
}

// Unity C# client
public class SoulClient : MonoBehaviour {
    private GrpcChannel channel;
    private SoulService.SoulServiceClient client;
    
    void Start() {
        channel = GrpcChannel.ForAddress("localhost:50051");
        client = new SoulService.SoulServiceClient(channel);
    }
    
    async Task<string> Ask(string query) {
        var response = await client.AskAsync(new AskRequest { Query = query });
        return response.Answer;
    }
}

// dora-rs node for physical AI
#[dora::node]
async fn physical_ai_node() {
    let soul = SoulKernel::new().await?;
    
    // Subscribe to sensor events
    dora::subscribe("camera/frame", |frame| {
        let result = soul.process_vision(frame).await?;
        dora::publish("motor/command", result.action);
    });
}

shell:
  name: "custom-shell"
  platform: "linux"
  capabilities:
    - audio_input
    - audio_output
    - display
  kernel_version: ">=0.1.0"

pub trait Shell {
    // Lifecycle
    fn initialize(&mut self, config: ShellConfig) -> Result<()>;
    fn shutdown(&mut self) -> Result<()>;
    
    // Communication
    fn handle_input(&mut self, input: UserInput) -> Result<()>;
    fn render_output(&mut self, output: SoulOutput) -> Result<()>;
    
    // Platform-specific
    fn get_capabilities(&self) -> Vec<Capability>;
}

// Kernel runs in-process
let kernel = SoulKernel::new()?;
let response = kernel.ask("Hello").await?;

service SoulService {
    rpc Ask(AskRequest) returns (AskResponse);
    rpc Remember(RememberRequest) returns (RememberResponse);
    rpc ExecuteSkill(SkillRequest) returns (stream SkillResponse);
}

// Pub/sub pattern for scalability
soul.subscribe("user_input", handle_input);
soul.publish("soul_response", response);

// Enable shell-specific logging
RUST_LOG=soul_kernel::shell=debug cargo run

# CPU profiling
perf record --call-graph=dwarf ./soul-shell
perf report

# Memory profiling
valgrind --leak-check=full ./soul-shell

#[test]
fn test_shell_lifecycle() {
    let mut shell = MockShell::new();
    shell.initialize(config).unwrap();
    
    // Test input handling
    shell.handle_input(UserInput::Text("Hello")).unwrap();
    
    // Verify output
    assert_eq!(shell.last_output(), "Hello! I'm your Soul.");
}