// Consistent stream naming patterns
pub mod streams {
    use eventcore::StreamId;
    
    pub fn session_stream(session_id: &SessionId) -> StreamId {
        StreamId::new(format!("session:{}", session_id))
    }
    
    pub fn analysis_stream(analysis_id: &AnalysisId) -> StreamId {
        StreamId::new(format!("analysis:{}", analysis_id))
    }
    
    pub fn user_settings_stream(user_id: &UserId) -> StreamId {
        StreamId::new(format!("user:{}:settings", user_id))
    }
    
    pub fn extraction_stream(extraction_id: &ExtractionId) -> StreamId {
        StreamId::new(format!("extraction:{}", extraction_id))
    }
}

// Commands define their own consistency boundaries
#[derive(Command)]
pub struct StartSessionAnalysis {
    #[stream]
    session_stream: StreamId,
    #[stream]
    analysis_stream: StreamId,
    analysis_config: AnalysisConfig,
}

#[async_trait]
impl CommandLogic for StartSessionAnalysis {
    type State = SessionAnalysisState;
    type Event = DomainEvent;
    
    async fn handle(
        &self,
        read_streams: ReadStreams<Self::StreamSet>,
        state: Self::State,
        stream_resolver: &mut StreamResolver,
    ) -> CommandResult<Vec<StreamWrite<Self::StreamSet, Self::Event>>> {
        let mut events = Vec::new();
        
        // Business logic validation
        require!(state.session.status == SessionStatus::Complete, "Cannot analyze incomplete session");
        require!(!state.analysis_exists, "Analysis already started for this session");
        
        // Emit events to multiple streams atomically
        emit!(
            events,
            &read_streams,
            self.session_stream.clone(),
            DomainEvent::AnalysisStarted { 
                session_id: state.session.id.clone(),
                analysis_id: self.analysis_config.id.clone(),
            }
        );
        
        emit!(
            events,
            &read_streams,
            self.analysis_stream.clone(),
            DomainEvent::AnalysisCreated {
                analysis_id: self.analysis_config.id.clone(),
                config: self.analysis_config.clone(),
                session_id: state.session.id.clone(),
            }
        );
        
        Ok(events)
    }
}

// Document stream lifecycles and relationships
pub struct StreamDocumentation {
    pub stream_pattern: &'static str,
    pub purpose: &'static str,
    pub lifecycle: StreamLifecycle,
    pub related_streams: Vec<&'static str>,
}

pub const STREAM_DOCS: &[StreamDocumentation] = &[
    StreamDocumentation {
        stream_pattern: "session:{session_id}",
        purpose: "Tracks all events for a single LLM session",
        lifecycle: StreamLifecycle::Bounded {
            created_by: "StartSession command",
            closed_by: "EndSession command",
            retention: RetentionPolicy::Days(90),
        },
        related_streams: vec!["analysis:{analysis_id}", "user:{user_id}:settings"],
    },
    StreamDocumentation {
        stream_pattern: "analysis:{analysis_id}",
        purpose: "Tracks analysis process and results",
        lifecycle: StreamLifecycle::Bounded {
            created_by: "StartSessionAnalysis command",
            closed_by: "CompleteAnalysis command",
            retention: RetentionPolicy::Days(365),
        },
        related_streams: vec!["session:{session_id}"],
    },
];

// Example: Version migration affecting multiple streams
#[derive(Command)]
pub struct MigrateSessionVersion {
    #[stream]
    session_stream: StreamId,
    #[stream]
    version_tracking_stream: StreamId,
    #[stream]
    migration_log_stream: StreamId,
    from_version: ModelVersion,
    to_version: ModelVersion,
}

// This command atomically updates all three streams
// EventCore ensures consistency across all streams

// Efficient querying across related streams
pub async fn get_session_with_analyses(
    session_id: &SessionId,
    event_store: &PostgresEventStore,
) -> Result<SessionWithAnalyses, DomainError> {
    // Read session stream
    let session_stream = streams::session_stream(session_id);
    let session_events = event_store.read_stream(&session_stream, None).await?;
    
    // Extract analysis IDs from session events
    let analysis_ids = extract_analysis_ids(&session_events);
    
    // Read all related analysis streams
    let mut analyses = Vec::new();
    for analysis_id in analysis_ids {
        let analysis_stream = streams::analysis_stream(&analysis_id);
        let analysis_events = event_store.read_stream(&analysis_stream, None).await?;
        analyses.push(build_analysis_projection(analysis_events)?);
    }
    
    Ok(SessionWithAnalyses {
        session: build_session_projection(session_events)?,
        analyses,
    })
}