┌─────────────────────────────────────────────────────────────────┐
│                           Daemon                                 │
│                                                                  │
│  IPC Handler ──► Deku::spawn() ──► ClaudeProcess                │
│                        │                  │                      │
│                        │                  │ stdout               │
│                        │                  ▼                      │
│                        │          ClaudeEventStream              │
│                        │                  │                      │
│                        │                  │ ClaudeEvent          │
│                        │                  ▼                      │
│                        └────────► Event Handler (Armin, IPC)     │
└─────────────────────────────────────────────────────────────────┘

use deku::{ClaudeConfig, ClaudeProcess, ClaudeEvent};

// Create configuration
let config = ClaudeConfig::new("Hello, Claude!", "/path/to/repo")
    .with_resume_session("previous-session-id"); // Optional

// Spawn the process
let mut process = ClaudeProcess::spawn(config).await?;

// Get the event stream
let mut stream = process.take_stream().unwrap();

// Process events
while let Some(event) = stream.next().await {
    match event {
        ClaudeEvent::Json { event_type, raw, .. } => {
            println!("Event: {} - {}", event_type, raw);
        }
        ClaudeEvent::SystemWithSessionId { claude_session_id, .. } => {
            println!("Claude session: {}", claude_session_id);
        }
        ClaudeEvent::Result { is_error, .. } => {
            println!("Completed (error={})", is_error);
        }
        ClaudeEvent::Finished { success, .. } => {
            println!("Process finished: {}", success);
            break;
        }
        ClaudeEvent::Stopped => {
            println!("Process was stopped");
            break;
        }
        _ => {}
    }
}

// From the process handle
process.stop();

// Or via the stop sender (can be cloned for use in other tasks)
let stop_tx = process.stop_sender();
tokio::spawn(async move {
    // Later...
    let _ = stop_tx.send(());
});