Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

108 KB
Raw Blame
//! The service's composition root: reads config and wires every adapter and
//! domain service into the HTTP server and its background workers.

use crate::{
    api::{
        self, MACRO_INTERNAL_USER_ID,
        context::{
            ApiContext, AuthorizationService, DocumentStorageServiceAuthKey, DssOwnedPurgeState,
            TaskPropertiesAdapter,
        },
    },
    config::{
        self, CalEventTypeContentNamesKey, CalWebhookSecretKey, Config, Environment,
        MetaAccessToken, MetaPixelId, MetaTestEventCode,
    },
    outbound,
    service::{self, s3::S3},
};
use account_manager::{
    domain::service::AccountManagerServiceImpl,
    inbound::axum_router::AccountManagerRouterState,
    outbound::{
        dm_delivery::DmAccountManagerDelivery, pg_account_manager_repo::PgAccountManagerRepo,
    },
};
use agent_session_realtime::{
    domain::service::AgentSessionLogConsumerService,
    outbound::redis_stream::consumer::RedisLogStreamConsumer,
};
use analytics_client::{AnalyticsClient, AnalyticsClientConfig, MetaConfig};
use anyhow::Context;
use bots::{domain::service::BotServiceImpl, outbound::pg_bots_repo::PgBotsRepo};
use cal::{
    domain::service::{CalConfig, CalEventMeta, CalWebhookServiceImpl},
    inbound::cal_webhook_router::CalWebhookRouterState,
    outbound::analytics_client::AnalyticsClientSink,
};
use calendar_events::domain::reminder_dispatch::CalendarReminderDispatchService;
use calendar_events::inbound::axum_router::CalendarRouterState;
use calendar_events::inbound::dispatch_worker::CalendarReminderDispatchWorker;
use calendar_events::outbound::notification_notifier::NotificationCalendarReminderNotifier;
use calendar_events::outbound::sqs_dispatch_queue::SqsCalendarDispatchQueue;
use call::{
    domain::service::CallServiceImpl,
    inbound::axum_router::{CallRouterState, InternalCallRouterState, WebhookRouterState},
    outbound::{
        ai_call_summarizer::AiCallSummarizer,
        livekit_rtc_client::LivekitRtcClient,
        pg_call_repo::PgCallRepo,
        pg_voice_repo::PgVoiceRepo,
        s3_recording_storage::{RecordingCloudFrontConfig, S3RecordingStorage},
    },
};
use channel_labels::{
    domain::service::ChannelLabelsServiceImpl, inbound::axum_router::ChannelLabelsRouterState,
    outbound::pg_channel_labels_repo::PgChannelLabelsRepo,
};
use channels::{
    domain::{
        list_service::ChannelListServiceImpl,
        service::ChannelServiceImpl,
        side_effects::{ChannelSideEffectService, SpawnedChannelEventDispatcher},
    },
    inbound::{axum_router::ChannelsRouterState, list_router::ChannelListRouterState},
    outbound::{
        connection_gateway_realtime::ConnectionGatewayChannelRealtimePublisher,
        contacts_dispatcher::ContactsChannelDispatcher,
        notification_sender::{NotificationChannelSender, NotificationReaderCompletion},
        pg_channel_reference_share_permissions::PgChannelReferenceSharePermissions,
        pg_channels_repo::PgChannelsRepo,
        pg_side_effect_context::PgChannelSideEffectContext,
    },
};
use collab_surface::inbound::axum_router::CollabSurfaceRouterState;
use connection::{
    domain::service::ConnectionServiceImpl,
    outbound::connection_gateway_client::ConnectionGatewayImpl,
};
use connection_gateway_client::client::ConnectionGatewayClient;
use documents_hex::domain::models::CloudFrontConfig;
use documents_hex::domain::service::DocumentServiceImpl;
use documents_hex::inbound::axum_router::DocumentRouterState;
use documents_hex::outbound::pg_document_repo::PgDocumentRepo;
use documents_hex::outbound::s3_upload_url::S3UploadUrlAdapter;
use dynamodb_client::DynamodbClient;
use email::{
    domain::{ports::ReadonlyEmailPreviewAdapter, service::EmailServiceImpl},
    outbound::EmailPgRepo,
};
use embedding::embedding_provider::openai::TextEmbedding3Small;
use entity_registry::OwnerGrantPolicy;
use entity_registry_db_utils::OwnedEntityRegistrar;
use favorites::{
    domain::{mutation_service::FavoritesMutationServiceImpl, service::FavoritesServiceImpl},
    inbound::axum_router::FavoritesRouterState,
    outbound::pg_favorites_repo::PgFavoritesRepo,
};
use foreign_entity::{
    domain::service::ForeignEntityServiceImpl, inbound::axum_router::ForeignEntityRouterState,
    outbound::pg_foreign_entity_repo::PgForeignEntityRepo,
};
use frecency::{domain::services::FrecencyQueryServiceImpl, outbound::postgres::FrecencyPgStorage};
use github::domain::service::{
    GithubSyncConfig, GithubSyncServiceImpl, InstallationTokenConfig, InstallationTokenService,
    PullRequestIndexService,
};
use github::inbound::pull_request_index_router::PullRequestIndexRouterState;
use github::outbound::connection_gateway_realtime::ConnectionGatewayGithubRealtime;
use github::outbound::github_sync_client::GithubSyncClientImpl;
use github::outbound::pg_github_sync_repo::PgGithubSyncRepo;
use github::outbound::pull_request_diff::GithubPullRequestDiffClient;
use github_pull_requests::{
    domain::service::{
        GithubPullRequestChangesServiceImpl, GithubPullRequestChangesetStore,
        GithubPullRequestServiceImpl,
    },
    inbound::{
        axum_router::GithubPullRequestRouterState,
        changes_router::GithubPullRequestChangesRouterState,
    },
    outbound::{
        pg_github_pull_request_repo::PgGithubPullRequestRepo,
        s3_patch_store::S3GithubPullRequestPatchStore,
    },
};
use graphql_scheduled_action::ScheduledActionGraphqlContext;
use harnesses::outbound::pg_harness_repo::PgHarnessRepo;
use initiative::{
    domain::service::InitiativeServiceImpl, inbound::axum_router::InitiativeRouterState,
    outbound::PgInitiativeRepo,
};
use lexical_client::LexicalClient;
use macro_auth::middleware::decode_jwt::JwtValidationArgs;
use macro_authorization::{
    InternalAuthConfig, MacroAuthJwtValidator, MacroAuthorizationServiceImpl,
    MacroAuthorizationState, PgBotAuthorizationRepo, PgBotAuthorizer, PgHarnessAuthorizationRepo,
    PgHarnessAuthorizer, PgUserApiKeyAuthorizationRepo, PgUserApiKeyAuthorizer,
};
use macro_env_var::maybe_env_vars;
use macro_event_broker::{KafkaEventPublisher, MacroEventBrokerService};
use macro_service_urls::{
    AiEditingWorkerUrl, ConnectionGatewayUrl, LexicalServiceUrl, StaticFileServiceUrl,
    SyncServiceUrl,
};
use macro_sha_count_client::Redis;
use notification::domain::service::{
    NotificationReaderService, PlatformArnConfig, SqsNotificationIngress,
    WebSocketNotificationConsumerService,
};
use notification::outbound::{notification_consumer::NotificationTopicConsumer, queue::SqsQueue};
use opensearch_client::OpensearchClient;
use projects_hex::{
    domain::service::ProjectServiceImpl,
    inbound::axum_router::ProjectRouterState,
    outbound::{
        DynamoBulkUploadAdapter, PgProjectRepo, S3ProjectUploadAdapter, ShaCountAdapter,
        SqsProjectSearchIndexer,
    },
};
use properties::{
    NotificationServiceImpl, PermissionServiceImpl, PropertiesPgRepo, PropertiesServiceImpl,
};
use rate_limit::{RateLimitServiceImpl, RedisRateLimitAdapter};
use reminders::{
    domain::service::dispatch::ReminderDispatchService,
    inbound::{axum_router::RemindersRouterState, dispatch_worker::DispatchWorker},
    outbound::{
        notification_notifier::NotificationReminderNotifier, pg_reminders_repo::PgRemindersRepo,
        sqs_dispatch_queue::SqsDispatchQueue,
    },
};
use scheduled_action::domain::read_service::ScheduledActionReadServiceImpl;
use scheduled_action::outbound::pg_scheduled_action_repo::PgScheduledActionRepo;
use secretsmanager_client::SecretManager;
use soup::{
    domain::service::SoupImpl, inbound::axum_router::SoupRouterState,
    outbound::pg_soup_repo::PgSoupRepo,
};
use soup_realtime::{
    domain::service::{SoupRealtimeConsumerService, SoupRealtimeServiceImpl},
    outbound::{
        entity_access::EntityAccessExpander, kafka_publisher::KafkaSoupRealtimePublisher,
        soup_consumer::SoupTopicConsumer,
    },
};
use sqlx::postgres::PgPoolOptions;
use std::{sync::Arc, time::Duration};
use sync_service_client::SyncServiceClient;
use system_properties::{PgSystemPropertiesRepository, SystemPropertiesServiceImpl};
use task_dedup::{
    TaskDedupService,
    outbound::{
        cohere::CohereReranker,
        connection_gateway::ConnectionGatewayTaskDedupNotifier,
        judge::AgentDuplicateJudge,
        postgres::{PgTaskMatchRepo, PgTaskVectorDb},
    },
};
use tokio_util::{sync::CancellationToken, task::TaskTracker};
use user_api_key::{
    domain::service::UserApiKeyServiceImpl, inbound::axum_router::UserApiKeyRouterState,
    outbound::pg_user_api_keys_repo::PgUserApiKeysRepo,
};

const SOUP_CONSUMER_RESTART_MAX_DELAY_SECS: u64 = 60;
const SOUP_CONSUMER_RESTART_ALERT_THRESHOLD: u32 = 5;

const DEFAULT_POSTHOG_HOST: &str = "https://us.i.posthog.com";

fn soup_consumer_restart_delay(consecutive_failures: u32) -> Duration {
    let exponent = consecutive_failures.saturating_sub(1).min(6);
    Duration::from_secs((1_u64 << exponent).min(SOUP_CONSUMER_RESTART_MAX_DELAY_SECS))
}

maybe_env_vars! {
    struct AppleBundleId;
    struct SnsApnsVoipPlatformArn;
}

/// Build the service from the environment and serve until shutdown.
// Not a `pub async fn`: see CS-73.
pub fn run() -> impl Future<Output = anyhow::Result<()>> {
    run_server()
}

async fn run_server() -> anyhow::Result<()> {
    let env = Environment::new_or_prod();

    let aws_config = macro_aws_config::get_macro_aws_config().await;

    let secretsmanager_client = secretsmanager_client::SecretsManager::new(
        aws_sdk_secretsmanager::Client::new(&aws_config),
    );

    // Parse our configuration from the environment, then resolve any secret-manager backed values.
    let config = Config::from_env()
        .context("expected to be able to generate config")?
        .resolve_remote_secrets(env, &secretsmanager_client)
        .await
        .context("expected to be able to resolve config secrets")?;
    let non_user_owners = config.non_user_owners()?;

    tracing::trace!("initialized config");

    // Per task. Normally each task runs about one query at a time; a larger
    // max only lets a slow database pile up more sessions.
    let (min_connections, max_connections): (u32, u32) = match config.environment {
        Environment::Production => (10, 50),
        Environment::Develop => (25, 100),
        Environment::Local => (15, 50),
    };

    let db = PgPoolOptions::new()
        .min_connections(min_connections)
        .max_connections(max_connections)
        .connect(&config.database_url)
        .await
        .context("could not connect to db")?;

    tracing::trace!(
        min_connections,
        max_connections,
        "initialized db connection"
    );

    let (readonly_min_connections, readonly_max_connections) = match config.environment {
        // Once all tasks use this cap, three dev tasks allow 60 replica sessions,
        // or 120 during a full rolling overlap.
        // Keep excess reads queued in the service instead of exhausting replica memory.
        Environment::Develop => (2, 20),
        Environment::Production | Environment::Local => (min_connections, max_connections),
    };

    let readonly_db = match PgPoolOptions::new()
        .min_connections(readonly_min_connections)
        .max_connections(readonly_max_connections)
        .connect(&config.database_url_readonly)
        .await
    {
        Ok(pool) => {
            tracing::trace!(
                min_connections = readonly_min_connections,
                max_connections = readonly_max_connections,
                "initialized readonly db connection"
            );
            pool
        }
        Err(e) => {
            tracing::warn!(error=?e, "failed to connect to readonly db, falling back to primary");
            db.clone()
        }
    };

    let dynamo_db = aws_sdk_dynamodb::Client::new(&aws_config);

    let dynamodb_client = DynamodbClient::new_from_client(
        dynamo_db.clone(),
        Some(config.bulk_upload_requests_table.as_ref().to_string()),
    );
    tracing::trace!("initialized dynamodb client");

    let s3_client = macro_aws_config::s3_client().await;

    tracing::trace!("initialized s3 client");

    let search_event_queue = macro_queues::SearchEventQueue::new();
    let document_delete_queue = macro_queues::DocumentDeleteQueue::new();
    let contacts_queue = macro_queues::ContactsQueue::new();
    let notification_queue = macro_queues::NotificationIngressQueue::new();
    let gmail_ops_queue = macro_queues::GmailOpsQueue::new();
    let email_scheduled_queue = macro_queues::EmailScheduledQueue::new();
    let reminder_dispatch_queue = macro_queues::ReminderDispatchQueue::new();
    let calendar_reminder_dispatch_queue = macro_queues::CalendarReminderDispatchQueue::new();
    let sqs_client = sqs_client::SQS::new(aws_sdk_sqs::Client::new(&aws_config))
        .search_event_queue(&search_event_queue)
        .document_delete_queue(&document_delete_queue)
        .gmail_ops_queue(&gmail_ops_queue)
        .gmail_label_write_batches(config.gmail_label_write_batches_enabled)
        .email_scheduled_queue(&email_scheduled_queue);
    let webhook_event_queue = webhook::outbound::SqsWebhookQueue::new(
        Arc::new(sqs_client.clone()),
        macro_queues::WebhookEventQueue::new().to_string(),
        config.webhook_queue_max_messages,
        config.webhook_queue_wait_time_seconds,
    );

    let contacts_ingress = Arc::new(contacts::domain::service::SqsContactsIngress {
        queue: contacts::outbound::ingress::SqsContactsQueue::new(
            aws_sdk_sqs::Client::new(&aws_config),
            contacts_queue.to_string(),
        ),
    });

    tracing::trace!("initialized sqs client");

    // Redis handles it own connection pool internally. Each time we use redis
    // we should be using redis_client.get_connection() to grab a specific connection
    let redis_client = redis::Client::open(config.redis_uri.to_string().as_ref())
        .expect("could not connect to redis client");

    match redis_client.get_connection().is_err() {
        true => {
            tracing::error!("unable to connect to redis");
        }
        false => {
            tracing::trace!("initialized redis connection");
        }
    }

    let dss_auth_key = DocumentStorageServiceAuthKey::new()?;

    let conn_gateway_client = ConnectionGatewayClient::new(
        config.internal_api_key.to_string(),
        ConnectionGatewayUrl::new()?.to_string(),
    );

    let sync_service_client = Arc::new(SyncServiceClient::new(
        config.sync_service_auth_key.as_ref().to_string(),
        SyncServiceUrl::new()?.to_string(),
    ));

    let lexical_client = Arc::new(LexicalClient::new(
        config.internal_api_key.to_string(),
        LexicalServiceUrl::new()?.to_string(),
    ));

    let jwt_validation_args =
        JwtValidationArgs::new_with_secret_manager(config.environment, &secretsmanager_client)
            .await?;

    let consumer_cancellation_token = CancellationToken::new();
    let consumer_tracker = TaskTracker::new();
    let event_broker_tracker = TaskTracker::new();
    let import_jobs = ai_tools::ImportJobs::new();
    let macro_event_broker = MacroEventBrokerService::new(
        KafkaEventPublisher::new(config.kafka_brokers.as_ref())
            .context("failed to create kafka event publisher")?,
        event_broker_tracker.clone(),
    );
    let bots_repo = PgBotsRepo::new(db.clone());
    // The agent API checks a newly selected MCP app against Pipedream's
    // directory, the same check the ConfigureAgent tool makes.
    let bots_service = BotServiceImpl::new(bots_repo, macro_event_broker.clone()).with_mcp_apps(
        ai_tools::PipedreamMcpAppCatalog::new(ai_tools::pipedream_client_from_env()?),
    );

    let authorization_service: AuthorizationService = MacroAuthorizationServiceImpl::new(
        MacroAuthJwtValidator::new(jwt_validation_args.clone()),
        InternalAuthConfig {
            api_key: dss_auth_key.as_ref().to_string(),
            default_user_id: Some(MACRO_INTERNAL_USER_ID.to_string()),
        },
        PgBotAuthorizer::new(PgBotAuthorizationRepo::new(db.clone())),
        PgUserApiKeyAuthorizer::new(PgUserApiKeyAuthorizationRepo::new(db.clone())),
    )
    .with_harness_authorizer(PgHarnessAuthorizer::new(PgHarnessAuthorizationRepo::new(
        db.clone(),
    )));
    let authorization_state = MacroAuthorizationState::new(Arc::new(authorization_service));
    let harnesses_service =
        harnesses::domain::service::HarnessServiceImpl::new(PgHarnessRepo::new(db.clone()));

    // Initialize OpenSearch client
    let opensearch_client = OpensearchClient::new(
        config.opensearch_url.to_string(),
        config.opensearch_username.to_string(),
        config.opensearch_password.to_string(),
    )
    .context("unable to create opensearch client")?;

    if let Err(e) = opensearch_client.health().await {
        tracing::error!(error=?e, "error connecting to opensearch");
        return Err(e);
    }
    tracing::trace!("initialized opensearch client");

    let frecency_storage = FrecencyPgStorage::new(db.clone());
    let frecency_service = FrecencyQueryServiceImpl::new(frecency_storage.clone());
    // DSS only reads CRM rows — no-op resolver keeps reqwest/scraper
    // out of this binary.
    let crm_service = crm::domain::service::CrmServiceImpl::new(
        crm::outbound::companies_repo::CompaniesRepositoryImpl::new(db.clone()),
        crm::outbound::no_op_resolver::NoOpCompanyMetadataResolver,
    );
    let entity_access_service = Arc::new(
        entity_access::domain::service::EntityAccessServiceImpl::new(
            entity_access::outbound::PgAccessRepository::new(db.clone()),
        ),
    );

    let email_service = EmailServiceImpl::new(
        EmailPgRepo::new(db.clone()),
        frecency_service.clone(),
        sqs_client.clone(),
        crm_service.clone(),
        entity_access_management::domain::service::EntityAccessManagementServiceImpl::new(
            entity_access_management::outbound::PgRepository::new(db.clone()),
        ),
        config.sent_undo_delay_secs,
    )
    .with_sender_provider(email::outbound::GmailSenderProvider::new(
        gmail_client::GmailClient::without_watch(),
        email::outbound::GmailTokenProviderImpl::lazy(
            redis_client.clone(),
            Arc::new(authentication_service_client::AuthServiceClient::new(
                config
                    .authentication_service_secret_key
                    .as_ref()
                    .to_string(),
                macro_service_urls::AuthServiceUrl::new()?.to_string(),
            )),
        ),
    ))
    .with_shared_thread_replies(email::outbound::EntityAccessSharedThreadReplies::new(
        db.clone(),
        (*entity_access_service).clone(),
    ))
    .with_macro_event_broker(macro_event_broker.clone());
    let readonly_email_service = ReadonlyEmailPreviewAdapter(
        EmailServiceImpl::new(
            EmailPgRepo::new(readonly_db.clone()),
            frecency_service.clone(),
            sqs_client.clone(),
            crm_service.clone(),
            entity_access_management::domain::service::EntityAccessManagementServiceImpl::new(
                entity_access_management::outbound::PgRepository::new(readonly_db.clone()),
            ),
            0,
        )
        .with_macro_event_broker(macro_event_broker.clone()),
    );
    let system_properties_service =
        SystemPropertiesServiceImpl::new(PgSystemPropertiesRepository::new(db.clone()));
    let ingress_queue = SqsQueue::new(
        aws_sdk_sqs::Client::new(&aws_config),
        notification_queue.to_string(),
    );
    let notification_ingress_service = Arc::new(SqsNotificationIngress {
        queue: ingress_queue.clone(),
    });
    let graphql_notification_reader: Arc<ai_tools::ToolNotificationService> =
        Arc::new(NotificationReaderService {
            repository: notification::outbound::repository::DbNotificationRepository::new(
                db.clone(),
            ),
            queue: ai_tools::ToolNotificationQueue::Sqs(ingress_queue.clone()),
            sns_endpoint: ai_tools::NoOpSnsEndpointManager,
            platform_config: PlatformArnConfig {
                apns_platform_arn: String::new(),
                fcm_platform_arn: String::new(),
                apns_voip_platform_arn: String::new(),
            },
            realtime: notification::domain::ports::NoopNotificationRealtimePublisher,
        });
    tracing::trace!("initialized notification ingress service");

    let permission_checker = PermissionServiceImpl::new(db.clone(), entity_access_service.clone());
    let notification_service = NotificationServiceImpl::new(
        SqsNotificationIngress {
            queue: ingress_queue,
        },
        db.clone(),
    );
    let properties_service = Arc::new(
        PropertiesServiceImpl::new(
            PropertiesPgRepo::new(db.clone()),
            Some(permission_checker),
            Some(notification_service),
        )
        .with_event_broker(macro_event_broker.clone())
        .with_initiative_assignees(Arc::new(
            initiative::domain::assignees::InitiativeAssignees::new(PgInitiativeRepo::new(
                db.clone(),
            )),
        )),
    );

    // Create the channel list service used by soup.
    // Create the legacy channel list router state for routes mounted under /comms.
    let agent_dm_profiles = Arc::new(outbound::agent_dm_authorizer::AgentDmProfileReader::new(
        PgChannelsRepo::new(db.clone()),
        PgBotsRepo::new(db.clone()),
    ));
    let channel_list_state = ChannelListRouterState::new(
        ChannelListServiceImpl::new(
            PgChannelsRepo::new(db.clone()),
            PgChannelsRepo::new(db.clone()),
            frecency_storage.clone(),
        )
        .with_agent_dm_profiles(agent_dm_profiles.clone()),
        authorization_state.clone(),
    );

    let s3 = Arc::new(S3::new(
        s3_client,
        config.document_storage_bucket.as_ref(),
        config.docx_document_upload_bucket.as_ref(),
        config.upload_staging_bucket.as_ref(),
    ));
    let system_properties_service = Arc::new(system_properties_service);

    let owned_entity_registrar =
        OwnedEntityRegistrar::new(OwnerGrantPolicy::new(PgBotsRepo::new(db.clone())));
    let document_repo = PgDocumentRepo::new(db.clone(), owned_entity_registrar.clone());
    let cloudfront_config = CloudFrontConfig {
        distribution_url: config
            .document_storage_service_cloudfront_distribution_url
            .as_ref()
            .to_string(),
        signer_public_key_id: config
            .document_storage_service_cloudfront_signer_public_key_id
            .as_ref()
            .to_string(),
        signer_private_key: config
            .document_storage_service_cloudfront_signer_private_key
            .as_ref()
            .to_string(),
        presigned_url_expiry_seconds: config.document_storage_service_presigned_url_expiry_seconds,
        browser_cache_expiry_seconds: config
            .document_storage_service_presigned_url_browser_cache_expiry_seconds,
    };
    let s3_upload_adapter = S3UploadUrlAdapter::new(
        macro_aws_config::s3_client().await,
        config.document_storage_bucket.as_ref(),
        config.docx_document_upload_bucket.as_ref(),
    );
    let markdown_initializer =
        documents_hex::outbound::markdown_init::LexicalSyncMarkdownInitializer::detached(
            lexical_client.as_ref().clone(),
            sync_service_client.as_ref().clone(),
        );

    let connection_gateway = Arc::new(ConnectionGatewayImpl::new(conn_gateway_client.clone()));

    let access_requests_repo =
        Arc::new(access_requests::outbound::postgres::PgRequestRepository::new(db.clone()));
    let access_requests_service =
        Arc::new(access_requests::domain::service::AccessRequestService::new(
            access_requests_repo.clone(),
            entity_access_service.clone(),
            access_requests::domain::ports::SystemClock,
        ));
    consumer_tracker.spawn(access_requests::inbound::dispatch::run(
        access_requests_repo,
        crate::outbound::access_requests::AccessRequestDelivery {
            withdrawal: Arc::new(
                notification::outbound::withdrawal::PgNotificationWithdrawal(db.clone()),
            ),
            ingress: notification_ingress_service.clone(),
            reader: graphql_notification_reader.clone(),
            connection: connection_gateway.clone(),
        },
        consumer_cancellation_token.clone(),
    ));

    let connection_service =
        ConnectionServiceImpl::new(entity_access_service.clone(), connection_gateway.clone());

    let entity_access_management_service =
        entity_access_management::domain::service::EntityAccessManagementServiceImpl::new(
            entity_access_management::outbound::PgRepository::new(db.clone()),
        );

    let chat_mutation_service =
        Arc::new(chat::domain::service::ChatServiceImpl::new_without_tools(
            chat::outbound::postgres::PgChatRepo::new(db.clone(), owned_entity_registrar.clone()),
            entity_access_management_service.clone(),
        ));

    let project_service = Arc::new(ProjectServiceImpl::new(
        PgProjectRepo::new(db.clone(), owned_entity_registrar.clone()),
        S3ProjectUploadAdapter::new(
            macro_aws_config::s3_client().await,
            config.document_storage_bucket.as_ref(),
            config.docx_document_upload_bucket.as_ref(),
            config.upload_staging_bucket.as_ref(),
        ),
        DynamoBulkUploadAdapter::new(dynamodb_client.clone()),
        ShaCountAdapter::new(Redis::new(redis_client.clone())),
        entity_access_management_service.clone(),
        SqsProjectSearchIndexer::new(Arc::new(sqs_client.clone()), macro_event_broker.clone()),
        if cfg!(feature = "local") {
            Some(uuid::uuid!("d50676e2-0a12-4c62-bc07-4b1cb6d8e9bc"))
        } else {
            None
        },
        macro_event_broker.clone(),
    ));

    let document_service = Arc::new(DocumentServiceImpl::new(
        document_repo,
        cloudfront_config,
        sync_service_client.as_ref().clone(),
        s3_upload_adapter,
        TaskPropertiesAdapter {
            system_properties: system_properties_service.clone(),
            properties: properties_service.clone(),
            entity_access_service: entity_access_service.clone(),
        },
        connection_service,
        entity_access_management_service.clone(),
        ForeignEntityServiceImpl::new(PgForeignEntityRepo::new(db.clone())),
        macro_event_broker.clone(),
    ));

    let foreign_entity_service = Arc::new(ForeignEntityServiceImpl::new(PgForeignEntityRepo::new(
        db.clone(),
    )));

    let github_sync_service_impl = GithubSyncServiceImpl::new(
        GithubSyncConfig {
            webhook_secret: config.github_webhook_secret_key.as_ref().to_string(),
            github_sync_app_url: config.github_sync_app_url.to_string(),
            sync_app_pem: config.github_sync_app_pem_secret_key.as_ref().to_string(),
            sync_app_client_id: config.github_sync_app_client_id.to_string(),
            sync_app_client_secret: config.github_sync_app_client_secret.to_string(),
            installation_state_secret: config.github_installation_state_secret.to_string(),
        },
        document_service.clone(),
        Arc::new(
            GithubPullRequestServiceImpl::new(
                ForeignEntityServiceImpl::new(PgForeignEntityRepo::new(db.clone())),
                PgGithubPullRequestRepo::new(db.clone()),
            )
            .with_event_publisher(
                github_pull_requests::broker::BrokerGithubPullRequestPublisher(
                    macro_event_broker.clone(),
                ),
            ),
        ),
        (*notification_ingress_service).clone(),
        PgGithubSyncRepo::new(db.clone()),
        GithubSyncClientImpl::default(),
        ConnectionGatewayGithubRealtime::new(conn_gateway_client.clone()),
    )
    .with_webhook_publisher(github::broker::BrokerGithubWebhookPublisher(
        macro_event_broker.clone(),
    ));

    let github_pull_request_index_state = PullRequestIndexRouterState {
        service: Arc::new(PullRequestIndexService::new(
            InstallationTokenConfig {
                client_id: config.github_sync_app_client_id.to_string(),
                private_key_pem: config.github_sync_app_pem_secret_key.as_ref().to_string(),
            },
            PgGithubSyncRepo::new(db.clone()),
            GithubSyncClientImpl::default(),
            GithubPullRequestServiceImpl::new(
                ForeignEntityServiceImpl::new(PgForeignEntityRepo::new(db.clone())),
                PgGithubPullRequestRepo::new(db.clone()),
            ),
        )),
        authorization_state: authorization_state.clone(),
    };

    let github_pull_request_state = GithubPullRequestRouterState::new(
        Arc::new(GithubPullRequestServiceImpl::new(
            ForeignEntityServiceImpl::new(PgForeignEntityRepo::new(db.clone())),
            PgGithubPullRequestRepo::new(db.clone()),
        )),
        entity_access_service.clone(),
        authorization_state.clone(),
    );

    let github_pull_request_changes_state = GithubPullRequestChangesRouterState::new(
        Arc::new(GithubPullRequestChangesServiceImpl::new(
            GithubPullRequestServiceImpl::new(
                ForeignEntityServiceImpl::new(PgForeignEntityRepo::new(db.clone())),
                PgGithubPullRequestRepo::new(db.clone()),
            ),
            GithubPullRequestChangesetStore::new(
                GithubPullRequestDiffClient::new(InstallationTokenService::new(
                    InstallationTokenConfig {
                        client_id: config.github_sync_app_client_id.to_string(),
                        private_key_pem: config.github_sync_app_pem_secret_key.as_ref().to_string(),
                    },
                    PgGithubSyncRepo::new(db.clone()),
                    GithubSyncClientImpl::default(),
                )),
                PgGithubPullRequestRepo::new(db.clone()),
                S3GithubPullRequestPatchStore::new(
                    macro_aws_config::s3_client().await,
                    config.github_pull_request_patch_bucket.to_string(),
                ),
            ),
        )),
        entity_access_service.clone(),
        authorization_state.clone(),
    );

    let foreign_entity_state = ForeignEntityRouterState::new(
        foreign_entity_service.clone(),
        entity_access_service.clone(),
        authorization_state.clone(),
    );

    // Cal.com webhooks → Meta Lead events. Both secrets are loaded here
    // (rather than on Config) to keep cal/Meta wiring colocated.
    let cal_webhook_secret = secretsmanager_client
        .get_maybe_secret_value(env, CalWebhookSecretKey::new()?)
        .await?;
    let cal_event_type_content_names_secret = secretsmanager_client
        .get_maybe_secret_value(env, CalEventTypeContentNamesKey::new()?)
        .await?;

    let analytics_client = Arc::new(AnalyticsClient::new(AnalyticsClientConfig {
        google_analytics: None,
        meta: Some(MetaConfig {
            pixel_id: MetaPixelId::new()?.as_ref().to_string(),
            access_token: MetaAccessToken::new()?.as_ref().to_string(),
            test_event_code: MetaTestEventCode::new().map(|v| v.as_ref().to_string()),
        }),
        posthog: None,
    }));

    let cal_event_type_meta: std::collections::HashMap<u64, CalEventMeta> =
        serde_json::from_str(cal_event_type_content_names_secret.as_ref())
            .context("CalEventTypeContentNames secret must be a JSON object mapping eventTypeId (u64) to { content_name: string, value: number (USD) }")?;
    let cal_webhook_service = CalWebhookServiceImpl::new(
        CalConfig {
            webhook_secret: cal_webhook_secret.as_ref().to_string(),
            event_type_meta: cal_event_type_meta,
        },
        AnalyticsClientSink::new(analytics_client.clone()),
    );
    let cal_webhook_state = CalWebhookRouterState::new(cal_webhook_service);

    // Call service (LiveKit)
    let transcription_agent_name = config
        .livekit_transcription_agent_name
        .value()
        .map(|v| v.to_owned());

    let internal_call_secret = config.internal_call_secret.value().map(|v| v.to_owned());

    anyhow::ensure!(
        transcription_agent_name.is_none() || internal_call_secret.is_some(),
        "LIVEKIT_TRANSCRIPTION_AGENT_NAME is set but INTERNAL_CALL_SECRET is missing — \
         the transcription agent will not be able to submit transcripts"
    );
    let livekit_rtc_client = LivekitRtcClient::new(
        config.livekit_server_url.as_ref(),
        config.livekit_api_key.as_ref(),
        config.livekit_api_secret.as_ref(),
        transcription_agent_name,
    );
    let call_connection_service =
        ConnectionServiceImpl::new(entity_access_service.clone(), connection_gateway.clone());
    let call_repo = PgCallRepo::new(db.clone());
    let egress_config = match (
        config::CallRecordingS3Bucket::new(),
        config::CallRecordingS3Region::new(),
        config::CallRecordingS3AccessKey::new(),
        config::CallRecordingS3Secret::new(),
    ) {
        (Some(bucket), Some(region), Some(access_key), Some(secret)) => {
            tracing::info!(bucket = bucket.as_ref(), "call recording enabled");
            Some(call::domain::models::EgressS3Config {
                bucket: bucket.as_ref().to_string(),
                region: region.as_ref().to_string(),
                access_key: access_key.as_ref().to_string(),
                secret: secret.as_ref().to_string(),
            })
        }
        _ => None,
    };
    let recording_storage = match &egress_config {
        Some(egress_config) => {
            let cloudfront_config = RecordingCloudFrontConfig {
                distribution_url: config
                    .document_storage_service_cloudfront_distribution_url
                    .as_ref()
                    .to_string(),
                signer_public_key_id: config
                    .document_storage_service_cloudfront_signer_public_key_id
                    .as_ref()
                    .to_string(),
                signer_private_key: config
                    .document_storage_service_cloudfront_signer_private_key
                    .as_ref()
                    .to_string(),
                presigned_url_expiry_seconds: config::CALL_RECORDING_PRESIGNED_URL_EXPIRY_SECONDS,
            };
            Some(S3RecordingStorage::new(egress_config.bucket.clone(), cloudfront_config).await)
        }
        None => None,
    };
    let mut call_service_builder = CallServiceImpl::<_, _, _, _, _, _, AiCallSummarizer>::new(
        call_repo,
        livekit_rtc_client,
        call_connection_service,
        (*entity_access_service).clone(),
        (*notification_ingress_service).clone(),
        recording_storage,
        config.livekit_server_url.as_ref(),
    )
    .with_summarizer(AiCallSummarizer::new(
        ai_usage::pg_recorder_with_enforcement(db.clone(), config.enable_ai_usage_enforcement),
    ));
    if let Some(secret) = internal_call_secret {
        call_service_builder = call_service_builder.with_internal_call_secret(secret);
    }
    if let Some(config) = egress_config {
        call_service_builder = call_service_builder.with_egress(config);
    }
    if let Some(base_url) = config::CallRingStatusBaseUrl::new() {
        call_service_builder =
            call_service_builder.with_ring_status_base_url(base_url.as_ref().to_owned());
    }

    // VoIP push is optional: enabled only when both env vars are present.
    // APPLE_BUNDLE_ID:           the app bundle ID (e.g. "com.macro.app.prod")
    // SNS_APNS_VOIP_PLATFORM_ARN: SNS platform app ARN for APNS_VOIP
    //
    // Option<VoipPushServiceImpl<...>> is used as the type parameter so the
    // type stays stable regardless of whether VoIP push is configured.
    let voip_sender = if let (Some(bundle_id), Some(voip_arn)) =
        (AppleBundleId::new(), SnsApnsVoipPlatformArn::new())
    {
        if voip_arn.is_empty() {
            tracing::warn!("voip push disabled: SNS_APNS_VOIP_PLATFORM_ARN is set but empty");
            None
        } else {
            let voip_repo =
                notification::outbound::repository::DbNotificationRepository::new(db.clone());
            let voip_mobile = notification::outbound::mobile::MobilePushAdapter {
                push_service: aws_sdk_sns::Client::new(&aws_config),
                apns_bundle_id: bundle_id.to_string(),
                voip_bundle_id: Some(format!("{}.voip", bundle_id.as_ref())),
            };
            tracing::info!(
                bundle_id = bundle_id.as_ref(),
                voip_arn = voip_arn.as_ref(),
                "voip push enabled"
            );
            Some(notification::domain::service::VoipPushServiceImpl::new(
                voip_repo,
                voip_mobile,
            ))
        }
    } else {
        tracing::info!("voip push disabled: APPLE_BUNDLE_ID or SNS_APNS_VOIP_PLATFORM_ARN not set");
        None
    };
    let call_service_builder = call_service_builder.with_voip_push_sender(voip_sender);

    let call_root_poster = call::outbound::channel_threads::LateCallRootPoster::default();
    let call_service_builder = call_service_builder
        .with_voice_repo(PgVoiceRepo::new(db.clone()))
        .with_event_broker(macro_event_broker.clone());
    let flags = feature_flags::outbound::posthog::PostHogFeatureFlags::new(
        config.posthog_host.value().unwrap_or(DEFAULT_POSTHOG_HOST),
        config.posthog_api_key.as_ref().to_owned(),
        // Flag evaluation is on the call-start path; fall back promptly.
        Duration::from_millis(300),
    )
    .map_err(|error| anyhow::anyhow!("invalid feature flag configuration: {error}"))?;
    let call_service_builder = call_service_builder.with_channel_threads(Arc::new(
        call::outbound::channel_threads::FlaggedChannelThreads::new(
            flags.clone(),
            call_root_poster.clone(),
        ),
    ));
    let call_service_builder = call_service_builder.with_programmatic_call_gate(
        call::outbound::programmatic_calls::FlaggedProgrammaticCalls(flags),
    );
    let call_public_rate_limiter = RateLimitServiceImpl {
        repo: RedisRateLimitAdapter {
            redis: redis_client.clone(),
        },
    };
    let call_service = Arc::new(call_service_builder.with_start_limiter(
        call::inbound::axum_router::RateLimitedCallStarts(call_public_rate_limiter.clone()),
    ));

    consumer_tracker.spawn({
        let service = call_service.clone();
        let cancellation_token = consumer_cancellation_token.clone();
        async move {
            cancellation_token
                .run_until_cancelled(call::inbound::stale_call_sweeper::run_stale_call_sweeper(
                    service,
                    call::inbound::stale_call_sweeper::SWEEP_INTERVAL,
                ))
                .await;
        }
    });

    let call_state = CallRouterState::new(
        call_service.clone(),
        entity_access_service.clone(),
        authorization_state.clone(),
    );
    let call_webhook_state = WebhookRouterState::new(call_service.clone());

    let webhook_repository = webhook::outbound::PgRepository::new(db.clone());
    let webhook_endpoint_scheme_policy = if matches!(env, Environment::Local) {
        webhook::domain::models::WebhookEndpointSchemePolicy::HttpAndHttps
    } else {
        webhook::domain::models::WebhookEndpointSchemePolicy::HttpsOnly
    };
    let webhook_http_client =
        webhook::outbound::ReqwestWebhookDeliveryClient::new_with_endpoint_scheme_policy(
            webhook_endpoint_scheme_policy,
        )
        .context("failed to create webhook HTTP client")?;
    let webhook_service =
        webhook::domain::service::WebhookServiceImpl::new_with_endpoint_scheme_policy(
            webhook_repository.clone(),
            webhook_http_client.clone(),
            webhook_endpoint_scheme_policy,
            macro_event_broker.clone(),
        );
    let webhook_rate_limiter = RateLimitServiceImpl {
        repo: RedisRateLimitAdapter {
            redis: redis_client.clone(),
        },
    };
    let webhook_state = webhook::inbound::axum_router::WebhookRouterState::new(
        webhook_service,
        webhook_rate_limiter,
        authorization_state.clone(),
    );

    let (webhook_stream_sender, _) =
        tokio::sync::broadcast::channel(webhook::domain::stream::WEBHOOK_STREAM_CHANNEL_CAPACITY);
    let sse_stream_service = webhook::domain::stream::WebhookEventStreamServiceImpl::new(
        webhook_stream_sender.clone(),
        entity_access_service.clone(),
        webhook_repository.clone(),
    );
    let sse_stream_state = webhook::inbound::stream_router::WebhookStreamRouterState::new(
        sse_stream_service,
        authorization_state.clone(),
    );
    consumer_tracker.spawn({
        let brokers = config.kafka_brokers.as_ref().to_string();
        let sender = webhook_stream_sender;
        let cancellation_token = consumer_cancellation_token.clone();
        async move {
            loop {
                let result = tokio::select! {
                    biased;
                    _ = cancellation_token.cancelled() => break,
                    result = webhook::inbound::kafka_stream_consumer::run_webhook_stream_consumer(
                        &brokers,
                        &sender,
                    ) => result,
                };

                if cancellation_token.is_cancelled() {
                    break;
                }
                if let Err(error) = result {
                    tracing::error!(
                        error = ?error,
                        "webhook SSE Kafka consumer stopped"
                    );
                    tokio::select! {
                        biased;
                        _ = cancellation_token.cancelled() => break,
                        _ = tokio::time::sleep(Duration::from_secs(1)) => {}
                    }
                }
            }
        }
    });

    let webhook_ingestion_service =
        webhook::domain::ingestion::WebhookEventIngestionServiceImpl::new(
            entity_access_service.clone(),
            webhook_repository,
            webhook_event_queue.clone(),
        );
    let webhook_delivery_repository =
        webhook::outbound::PgWebhookDeliveryRepository::new(db.clone());
    let webhook_delivery_service = webhook::domain::delivery::WebhookEventDeliveryServiceImpl::new(
        webhook_delivery_repository,
        webhook_http_client,
    );
    let webhook_worker = webhook::inbound::worker::WebhookEventWorker::new(
        webhook_event_queue,
        webhook_delivery_service,
    );
    let webhook_worker_task = tokio::spawn(async move {
        tracing::info!("starting webhook event worker");
        webhook_worker.run().await;
    });
    tokio::spawn(async move {
        match webhook_worker_task.await {
            Ok(()) => tracing::error!("webhook event worker exited unexpectedly"),
            Err(error) => {
                tracing::error!(error = ?error, "webhook event worker exited unexpectedly");
            }
        }
    });

    let webhook_consumer_brokers = config.kafka_brokers.as_ref().to_string();
    consumer_tracker.spawn({
        let cancellation_token = consumer_cancellation_token.clone();
        async move {
            loop {
                if cancellation_token.is_cancelled() {
                    break;
                }

                tracing::info!("starting webhook event consumer");
                let result = webhook::inbound::kafka_consumer::run_webhook_event_consumer(
                    &webhook_consumer_brokers,
                    webhook_ingestion_service.clone(),
                    cancellation_token.cancelled(),
                )
                .await;

                if cancellation_token.is_cancelled() {
                    break;
                }

                match result {
                    Ok(()) => tracing::error!("webhook event consumer exited unexpectedly"),
                    Err(error) => {
                        tracing::error!(error = ?error, "webhook event consumer exited unexpectedly");
                    }
                }

                tokio::select! {
                    biased;
                    _ = cancellation_token.cancelled() => break,
                    _ = tokio::time::sleep(Duration::from_secs(5)) => {}
                }
            }
        }
    });

    let (timeline_publisher, timeline_delivery) = crate::service::activity::TimelinePublisher::new(
        conn_gateway_client.clone(),
        messages::outbound::connection_gateway::ConnectionGatewayMessages(Arc::new(
            conn_gateway_client.clone(),
        )),
        messages::outbound::entity_access_audience::EntityAccessMessageAudience(
            (*entity_access_service).clone(),
        ),
    );
    consumer_tracker.spawn({
        let cancellation_token = consumer_cancellation_token.clone();
        async move {
            tokio::select! {
                _ = cancellation_token.cancelled() => {},
                _ = timeline_delivery => {},
            }
        }
    });
    let activity_consumer_brokers = config.kafka_brokers.as_ref().to_string();
    let editing_activity = Arc::new(
        documents_hex::outbound::editing_activity::RedisEditingActivityStore::new(
            redis_client.clone(),
        ),
    );
    consumer_tracker.spawn({
        let cancellation_token = consumer_cancellation_token.clone();
        let activity_repo = activity::outbound::pg_activity_repo::PgActivityRepo::new(db.clone());
        let activity_realtime = activity::domain::announcements::ActivityAnnouncements::new(
            activity::KafkaActivityRealtimePublisher::new(macro_event_broker.clone()),
            crate::service::activity::EntityAccessActivityAudience::new(
                entity_access_service.clone(),
            ),
        );
        async move {
            let consumer = activity::inbound::kafka_consumer::ActivityConsumer::<
                _,
                crate::service::activity::ActivitySourceEvent,
                _,
                _,
            >::new(
                activity_repo,
                move |event| {
                    let editing_activity = editing_activity.clone();
                    async move {
                        crate::service::activity::ingest(event, editing_activity.as_ref()).await
                    }
                },
                (activity_realtime, timeline_publisher),
            );
            loop {
                if cancellation_token.is_cancelled() {
                    break;
                }

                tracing::info!("starting activity consumer");
                let result = consumer
                    .run(&activity_consumer_brokers, cancellation_token.cancelled())
                    .await;

                if cancellation_token.is_cancelled() {
                    break;
                }

                match result {
                    Ok(()) => tracing::error!("activity consumer exited unexpectedly"),
                    Err(error) => {
                        tracing::error!(error = ?error, "activity consumer exited unexpectedly");
                    }
                }

                tokio::select! {
                    biased;
                    _ = cancellation_token.cancelled() => break,
                    _ = tokio::time::sleep(Duration::from_secs(5)) => {}
                }
            }
        }
    });

    // Links archived calls to the CRM records of the people on them.
    let crm_call_link_brokers = config.kafka_brokers.as_ref().to_string();
    consumer_tracker.spawn({
        let cancellation_token = consumer_cancellation_token.clone();
        let consumer = crm::inbound::call_archived::CallArchivedConsumer::new(
            crm::domain::call_links::CallRecordLinker::new(
                call::domain::service::CallRecordQueryServiceImpl::new(PgCallRepo::new(
                    db.clone(),
                )),
                crm::outbound::call_link::PgCallCrmLinker::new(
                    db.clone(),
                    (*system_properties_service).clone(),
                ),
            ),
        );
        async move {
            loop {
                if cancellation_token.is_cancelled() {
                    break;
                }

                tracing::info!("starting CRM call-link consumer");
                let result = consumer
                    .run(&crm_call_link_brokers, cancellation_token.cancelled())
                    .await;

                if cancellation_token.is_cancelled() {
                    break;
                }

                match result {
                    Ok(()) => tracing::error!("CRM call-link consumer exited unexpectedly"),
                    Err(error) => {
                        tracing::error!(error = ?error, "CRM call-link consumer exited unexpectedly");
                    }
                }

                tokio::select! {
                    biased;
                    _ = cancellation_token.cancelled() => break,
                    _ = tokio::time::sleep(Duration::from_secs(5)) => {}
                }
            }
        }
    });

    let call_internal_state = InternalCallRouterState::new(call_service.clone());

    // Create the SQS worker for delete document processing before config is moved.
    #[cfg(feature = "delete_document_worker")]
    let delete_document_worker = sqs_worker::SQSWorker::new(
        aws_sdk_sqs::Client::new(&aws_config),
        document_delete_queue.to_string(),
        config.queue_max_messages,
        config.queue_wait_time_seconds,
    );

    let sqs_client = Arc::new(sqs_client);
    let conn_gateway_client = Arc::new(conn_gateway_client);

    // MacroConfig reads the shared OPENAI_API_KEY from Doppler's APP_SECRETS_JSON
    // or the local environment. Validate once before constructing consumers.
    let openai_api_key = config.openai_api_key.as_ref().to_owned();
    anyhow::ensure!(
        !openai_api_key.trim().is_empty(),
        "OpenAI API key is required for task dedup embeddings and dictation",
    );
    let cohere_api_key = config.cohere_api_key.as_ref().to_owned();
    anyhow::ensure!(
        !cohere_api_key.trim().is_empty(),
        "Cohere API key is required for task dedup reranking",
    );
    let dictation_state = dictation::inbound::axum_router::DictationRouterState::new(
        dictation::domain::DictationServiceImpl::new(
            dictation::outbound::WhisperTranscriber::new(&config.openai_api_key)?,
            dictation::outbound::SymphoniaRecordingInspector,
            ai_usage::pg_recorder_with_enforcement(db.clone(), config.enable_ai_usage_enforcement),
        ),
        RateLimitServiceImpl {
            repo: RedisRateLimitAdapter {
                redis: redis_client.clone(),
            },
        },
        authorization_state.clone(),
    );
    let task_dedup_service = Arc::new(TaskDedupService::new(
        TextEmbedding3Small::new(openai_api_key),
        PgTaskVectorDb::new(db.clone()),
        CohereReranker::new(cohere_api_key),
        Arc::new(AgentDuplicateJudge::new(
            ai_usage::pg_recorder_with_enforcement(db.clone(), config.enable_ai_usage_enforcement),
        )),
        Arc::new(ConnectionGatewayTaskDedupNotifier::new(
            conn_gateway_client.clone(),
        )),
        Arc::new(PgTaskMatchRepo::new(db.clone())),
    ));
    let channels_repo = PgChannelsRepo::new(db.clone());
    // Built-in agents read the same committed-post stream as hosted and
    // external agents, for channel and document posts alike, so the channel
    // side effects no longer carry their own trigger queue.
    let (bot_trigger_sender, bot_trigger_receiver) = tokio::sync::mpsc::unbounded_channel();

    let channel_side_effects = ChannelSideEffectService::new(
        PgChannelSideEffectContext::new(db.clone()),
        ConnectionGatewayChannelRealtimePublisher::new(conn_gateway_client.clone()),
        NotificationChannelSender::new(notification_ingress_service.clone()).with_completion(
            NotificationReaderCompletion::new(
                graphql_notification_reader.clone(),
                Arc::new(notification::outbound::withdrawal::PgNotificationWithdrawal(db.clone())),
            ),
        ),
        ContactsChannelDispatcher::new(contacts_ingress.clone()),
    )
    .with_macro_event_broker(macro_event_broker.clone());

    let channels_service = Arc::new(
        ChannelServiceImpl::with_dependencies(
            channels_repo.clone(),
            SpawnedChannelEventDispatcher::new(channel_side_effects.clone()),
            PgChannelReferenceSharePermissions::new(db.clone(), entity_access_service.clone()),
        )
        .with_agent_direct_messages(Arc::new(channels::domain::agent_dm::AgentDmService::new(
            channels_repo,
            outbound::agent_dm_authorizer::BotServiceDmAuthorizer(bots_service.clone()),
            SpawnedChannelEventDispatcher::new(channel_side_effects.clone()),
        )))
        .with_comment_parent_access(Arc::new(
            channels::outbound::entity_access_comment_parents::EntityAccessCommentParents::new(
                entity_access_service.clone(),
            ),
        ))
        .with_picture_files(
            channels::outbound::static_file_pictures::StaticFileChannelPictures::new(
                static_file_service_client::StaticFileServiceClient::new(
                    config.internal_api_key.to_string(),
                    StaticFileServiceUrl::new()?.to_string(),
                ),
            ),
        ),
    );

    // One message implementation for channels and documents. Committed changes fan
    // out to the broker, the local agent queue, and the parent's own delivery: channel
    // messages keep their notifications, activity, and sharing side effects and send
    // the common `message_update` payload; document discussions get the common
    // payload and document comment notifications.
    let message_realtime = messages::outbound::connection_gateway::ConnectionGatewayMessages(
        conn_gateway_client.clone(),
    );
    let discussion_delivery = messages::domain::delivery::DiscussionDelivery::new(
        messages::outbound::pg_discussion_context::PgDiscussionContext(db.clone())
            .with_initiatives(
                initiative::domain::lookup::InitiativeLookup::new(
                    initiative::outbound::PgInitiativeRepo::new(db.clone()),
                ),
                properties_service.clone(),
            )
            .with_crm(crm::outbound::lookup::PgCrmParentReader::new(db.clone())),
        messages::outbound::entity_access_audience::EntityAccessMessageAudience(
            (*entity_access_service).clone(),
        ),
        message_realtime.clone(),
        messages::outbound::notification_sender::MessageNotificationSender(
            notification_ingress_service.clone(),
        ),
    )
    .with_sharing(messages::outbound::pg_discussion_context::PgDiscussionContext(db.clone()));
    let annotation_service = Arc::new(messages::domain::annotations::AnnotationService::new(
        macro_db_client::annotations::repository::PgAnnotationRepository(db.clone()),
        (*entity_access_service).clone(),
        discussion_delivery.clone(),
    ));
    let channel_delivery = channels::domain::message_delivery::ChannelMessageDelivery::new(
        PgChannelsRepo::new(db.clone()),
        SpawnedChannelEventDispatcher::new(channel_side_effects.clone()),
        PgChannelReferenceSharePermissions::new(db.clone(), entity_access_service.clone()),
        message_realtime,
        channels::outbound::pg_agent_creations::PgAgentCreations::new(db.clone()),
    );
    let message_service = Arc::new(
        messages::domain::service::MessageService::new(
            messages::outbound::pg_message_repo::PgMessageRepository::new(db.clone())
                .with_initiatives(initiative::domain::lookup::InitiativeLookup::new(
                    initiative::outbound::PgInitiativeRepo::new(db.clone()),
                ))
                .with_crm(crm::outbound::lookup::PgCrmParentReader::new(db.clone())),
            messages::domain::effects::MessageEffects::new(
                messages::outbound::broker::BrokerMessagePublisher::new(macro_event_broker.clone()),
                channel_bots::outbound::conversation::LocalBotPublisher::new(bot_trigger_sender),
                messages::domain::delivery::ParentMessagePublisher::new(
                    channel_delivery,
                    discussion_delivery,
                ),
            ),
        )
        .with_activity(activity::outbound::pg_activity_repo::PgActivityRepo::new(
            db.clone(),
        ))
        .with_group_recipients(channels::domain::group_mentions::ChannelGroupRecipients(
            PgChannelsRepo::new(db.clone()),
        ))
        .with_mention_extractor(lexical_mention_extractor::LexicalMentionExtractor::new(
            lexical_client.clone(),
        ))
        .with_references(
            messages::outbound::entity_access_audience::EntityAccessMessageReferences(
                (*entity_access_service).clone(),
            ),
        ),
    );
    let message_commands: Arc<dyn messages::domain::api::MessageCommands> = message_service.clone();
    let call_roots: Arc<dyn messages::domain::api::CallRootPoster> = message_service.clone();
    if call_root_poster.set(call_roots).is_err() {
        tracing::error!("the call root poster was set twice");
    }
    let guest_chat_service = Arc::new(
        messages::domain::service::guest_chat::GuestChatService::new(
            message_service.clone(),
            call_service.clone(),
        ),
    );
    let messages_state = messages::inbound::axum_router::MessagesRouterState {
        service: message_service.clone(),
        access: entity_access_service.clone(),
        authorization: authorization_state.clone(),
    };

    let teammate_dms_brokers = config.kafka_brokers.as_ref().to_string();
    consumer_tracker.spawn({
        let cancellation_token = consumer_cancellation_token.clone();
        let channels = (*channels_service).clone();
        async move {
            loop {
                if cancellation_token.is_cancelled() {
                    break;
                }

                tracing::info!("starting teammate DM consumer");
                let result = channels::inbound::teammate_dms_consumer::run_teammate_dms_consumer(
                    &teammate_dms_brokers,
                    channels.clone(),
                    cancellation_token.cancelled(),
                )
                .await;

                if cancellation_token.is_cancelled() {
                    break;
                }

                match result {
                    Ok(()) => tracing::error!("teammate DM consumer exited unexpectedly"),
                    Err(error) => {
                        tracing::error!(
                            error = ?error,
                            "teammate DM consumer exited unexpectedly"
                        );
                    }
                }

                tokio::select! {
                    biased;
                    _ = cancellation_token.cancelled() => break,
                    _ = tokio::time::sleep(Duration::from_secs(5)) => {}
                }
            }
        }
    });

    // Wire Macro AI to react to mentions with the classic in-channel chat
    // reply. The router posts replies through the channel service we just
    // built and runs the agent loop in-process with the channel-bot toolset:
    // a channel has no composer to finish a chat-deferred user tool in, so
    // calendar event creation executes directly and SendEmail is unavailable.
    // Agent sessions belong to a different bot entirely
    // (`bot_id::MACRO_NEW_BOT_ID`, served by the harness), so the two paths
    // can never answer the same mention.
    // This host holds no authentication-service key, so its counted usage is
    // settled by that service's reconciliation sweep rather than requested
    // after each completion.
    let mut macro_agent_tool_context = ai_tools::build_tool_service_context_from_env(
        db.clone(),
        event_broker_tracker.clone(),
        import_jobs.clone(),
        config.enable_ai_usage_enforcement,
        config.ai_pricing(),
        ai_usage::pg_recorder_with_enforcement(db.clone(), config.enable_ai_usage_enforcement),
        Some(Arc::new(
            mcp_client::outbound::auth_service_github_tokens::AuthServiceGithubTokens::new(
                authentication_service_client::AuthServiceClient::new(
                    config
                        .authentication_service_secret_key
                        .as_ref()
                        .to_string(),
                    macro_service_urls::AuthServiceUrl::new()?.to_string(),
                ),
            ),
        )),
    )
    .await
    .context("failed to build Macro agent tool context")?;
    // Wire the agent's SendChannelMessage tool to this service's own
    // side-effect pipeline so agent-posted messages share the exact instance
    // used by the HTTP API, including the in-process bot trigger sender (the
    // env builder wires an equivalent pipeline, but without bot triggers).
    macro_agent_tool_context.channel_tool_context =
        ai_tools::build_channel_tool_context_with_dispatcher(
            db.clone(),
            std::sync::Arc::new(SpawnedChannelEventDispatcher::new(
                channel_side_effects.clone(),
            )),
            message_service.clone(),
        );
    let macro_agent_tools = ai_tools::tools_for(ai_tools::AiHost::ChannelBot);
    let conversation_access = Arc::new(
        channel_bots::outbound::conversation::EntityAccessConversation(
            entity_access_service.clone(),
        ),
    );
    let admission = macro_agent_tool_context.admission.clone();
    // Document AI edits over HTTP share the channel agent's admission.
    let document_editing_worker = Arc::new(
        documents_hex::outbound::editing_worker_client::ReqwestEditingWorkerClient::from_url(
            AiEditingWorkerUrl::new()?.to_string(),
        ),
    );
    let document_ai_editing = Arc::new(documents_hex::domain::ai_editing::AiEditingService::new(
        document_editing_worker.clone(),
        admission.clone(),
        ai_usage::pg_recorder_with_enforcement(db.clone(), config.enable_ai_usage_enforcement),
    ));
    // The file-document routes read and write what the matching AI tools do.
    let document_files = Arc::new(
        documents_hex::outbound::s3_document_files::S3DocumentFiles::new(
            db.clone(),
            macro_aws_config::s3_client().await,
            config.document_storage_bucket.to_string(),
        ),
    );
    let word_documents = Arc::new(
        documents_hex::domain::word_document::WordDocumentService::new(
            document_service.clone(),
            document_editing_worker,
            sync_service_client.clone(),
            document_files.clone(),
            config.document_permission_jwt.as_ref().to_string(),
        ),
    );
    let bot_trigger_router = channel_bots::inbound::BotTriggerRouter::new_with_admission(
        message_service.clone(),
        conversation_access.clone(),
        Arc::new(channel_bots::outbound::AgentLoopResponder::new(
            macro_agent_tool_context,
            macro_agent_tools,
        )),
        Arc::new(
            channel_bots::domain::trigger_detector::MentionOrInferredDetector::new(
                message_service.clone(),
                conversation_access,
                Arc::new(channel_bots::outbound::FastModelTriggerClassifier::new(
                    ai_usage::pg_recorder_with_enforcement(
                        db.clone(),
                        config.enable_ai_usage_enforcement,
                    ),
                )),
            )
            .with_admission(admission.clone()),
        ),
        Arc::new(channel_bots::outbound::PrimaryCalendarTimeZones::new(
            Arc::new(calendar_events::domain::service::CalendarService::new(
                calendar_events::outbound::pg::PgCalendarRepository::new(readonly_db.clone()),
            )),
        )),
        Arc::new(channel_bots::outbound::LexicalCommentMarks::new(
            (*lexical_client).clone(),
        )),
        admission,
    );
    bot_trigger_router.spawn(bot_trigger_receiver);

    let channel_bot_webhook_state =
        bots::inbound::channel_webhook_router::ChannelBotWebhookRouterState::new(
            bots_service.clone(),
            message_commands.clone(),
            (*entity_access_service).clone(),
            authorization_state.clone(),
        );

    let slack_limits = slack_integration::domain::models::ImportLimits::default();
    let slack_enabled = config.slack_import_enabled;
    let slack_service = api::context::SlackService::new(
        slack_integration::outbound::pg_slack_import_repo::PgSlackImportRepo::new(
            db.clone(),
            slack_limits,
        ),
        slack_integration::outbound::s3_storage::S3ImportStorage::new(
            macro_aws_config::s3_client().await,
            config.upload_staging_bucket.as_ref().to_owned(),
            slack_limits,
        )
        .map_err(|_| anyhow::anyhow!("invalid Slack import storage configuration"))?,
        slack_integration::outbound::import_ledger::CanonicalImportLedger::new(
            import::outbound::pg_import_repo::PgImportRepo::new(db.clone()),
        ),
        slack_integration::outbound::gateway_notifier::GatewayImportNotifier::new(
            conn_gateway_client.clone(),
        ),
        api::context::SlackAdminAuthorizer(
            entity_access_service.clone(),
            entity_access::outbound::PgAccessRepository::new(db.clone()),
        ),
        Box::new(move |_| slack_enabled),
        slack_limits,
    )?;
    let slack_state = slack_integration::inbound::axum_router::SlackRouterState {
        service: Arc::new(slack_service),
        entity_access_service: entity_access_service.clone(),
        authorization_state: authorization_state.clone(),
    };
    let external_chat_state = crate::external_chat::build(crate::external_chat::Dependencies {
        redis: redis_client.clone(),
        static_files: static_file_service_client::StaticFileServiceClient::new(
            config.internal_api_key.to_string(),
            StaticFileServiceUrl::new()?.to_string(),
        ),
        pool: db.clone(),
        access: entity_access_service.clone(),
        authorization: authorization_state.clone(),
        notifications: notification_ingress_service.clone(),
        connection_gateway: conn_gateway_client.clone(),
        tracker: consumer_tracker.clone(),
        cancellation: consumer_cancellation_token.clone(),
    });

    // Held by value here and behind an `Arc` in the router state: the impl is a
    // pool handle, so cloning is cheap and `SoupImpl` needs an owned service.
    // Additional connections for guards spanning email I/O. HTTP requests and
    // dispatch share this budget, independently of the main data pool.
    let followup_lock_capacity = match config.environment {
        Environment::Production => 32,
        Environment::Develop => 16,
        Environment::Local => 8,
    };
    let email_followups = reminders::domain::email_followup::service::EmailFollowupService::new(
        PgRemindersRepo::with_followup_lock_capacity(db.clone(), followup_lock_capacity),
        email_service.clone(),
    );
    let reminders_service =
        reminders::domain::email_followup::reminder_service::EmailRemindersService::new(
            email_followups.clone(),
        )
        .with_entity_access((*entity_access_service).clone());

    let document_creator = documents_hex::domain::create::DocumentCreator::new(
        document_service.clone(),
        markdown_initializer,
        documents_hex::outbound::document_bytes_upload::ReqwestDocumentBytesUploader::default(),
        documents_hex::outbound::mention_tracker::LexicalCommsMentionTracker::new(
            db.clone(),
            lexical_client.clone(),
        ),
    );
    // Forms' ids are their surfaces' ids, so the public surface API asks the
    // forms domain which ids are taken.
    let collab_surface_service = Arc::new(
        collab_surface::outbound::pg_collab_surface_service(
            db.clone(),
            lexical_client.as_ref().clone(),
            sync_service_client.as_ref().clone(),
            config.document_permission_jwt.as_ref().to_string(),
        )
        .with_form_ids(Arc::new(
            forms::outbound::collaborative_layout::RepositoryFormIds::new(Arc::new(
                forms::outbound::pg_forms_repo::PgFormsRepo::new(db.clone()),
            )),
        )),
    );

    let initiative_service = Arc::new(
        InitiativeServiceImpl::new(
            PgInitiativeRepo::new(db.clone()),
            initiative_description::InitiativeDescriptionSurfacesAdapter::new(
                collab_surface_service.clone(),
            ),
            Arc::new(initiative::outbound::resources::ProjectResources::new(
                properties_service.clone(),
                system_properties_service.clone(),
                entity_access_service.clone(),
            )),
        )
        .with_event_publisher(Arc::new(
            initiative::outbound::event_publisher::BrokerInitiativeEventPublisher::new(
                macro_event_broker.clone(),
            ),
        )),
    );

    // Shared by the databases router and the unified entity-mutation router.
    let databases_service = Arc::new(databases::wiring::build_service(
        db.clone(),
        entity_access_service.clone(),
        databases::outbound::gateway_event_publisher::GatewayTableEventPublisher::new(
            conn_gateway_client.as_ref().clone(),
        ),
        macro_event_broker.clone(),
    ));
    let pipeline_service = Arc::new(crm::domain::pipelines::PipelineServiceImpl::new(
        crm::outbound::pipelines::PgPipelineRepo::new(
            db.clone(),
            databases::outbound::pg_cell_store::PgCellStore::new(
                db.clone(),
                properties::outbound::properties_pg_repo::PropertiesPgRepo::new(db.clone()),
            ),
        ),
        databases_service.clone(),
        entity_access_service.clone(),
        crm::outbound::stage_definitions::PropertiesStageDefinitionStore::new(
            properties_service.clone(),
        ),
    ));

    let database_webhooks_service = Arc::new(database_webhooks::wiring::build_service(
        db.clone(),
        databases_service.clone(),
        entity_access_service.clone(),
    ));

    let forms_service = Arc::new(forms::wiring::build_service(
        db.clone(),
        databases_service.clone(),
        entity_access_service.clone(),
        forms::outbound::gateway_event_publisher::GatewayFormEventPublisher::new(
            conn_gateway_client.as_ref().clone(),
        ),
        macro_event_broker.clone(),
        collab_surface_service.clone(),
        static_file_service_client::StaticFileServiceClient::new(
            config.internal_api_key.to_string(),
            StaticFileServiceUrl::new()?.to_string(),
        ),
    ));

    // Individual initiative and agent-session reads preserve read-after-write
    // consistency when a newly created entity opens immediately, as does
    // realtime patch hydration, which runs right after the write it announces.
    // Lists retain the replica reader. Reuse Soup hydration so detail and
    // mutation metadata include viewer history.
    let primary_entity_soup = Arc::new(
        SoupImpl::new(
            PgSoupRepo::new(readonly_pool::ReadOnlyPool(db.clone())),
            frecency_service.clone(),
            ReadonlyEmailPreviewAdapter(email_service.clone()),
            ChannelListServiceImpl::new(
                PgChannelsRepo::new(db.clone()),
                PgChannelsRepo::new(db.clone()),
                frecency_storage.clone(),
            )
            .with_agent_dm_profiles(agent_dm_profiles),
            call::domain::service::CallRecordQueryServiceImpl::new(PgCallRepo::new(db.clone())),
            crm_service.clone(),
            GithubPullRequestServiceImpl::new(
                ForeignEntityServiceImpl::new(PgForeignEntityRepo::new(db.clone())),
                PgGithubPullRequestRepo::new(db.clone()),
            ),
        )
        .with_agent_branches(agent_changes::outbound::postgres::PgChangesetRepo::new(
            db.clone(),
        )),
    );

    // SQL predicates and follow-up reads use the primary, matching the catalog
    // versions and writes; replica lag must not select stale rows for an edit.
    let sql_service = databases_sql::DatabasesSql::new(
        databases_service.clone(),
        entity_access_service.clone(),
        primary_entity_soup.clone(),
        Arc::new(contacts::domain::service::ContactsDomainService {
            repository: contacts::outbound::repository::DbContactsRepository::new(db.clone()),
            notifier: None::<contacts::outbound::gateway::ConnectionGatewayNotifier>,
        }),
    );

    let favorites_service = Arc::new(FavoritesServiceImpl::new(PgFavoritesRepo::new(db.clone())));

    // Keep the replica-backed Soup reader alongside the primary-backed email
    // writer in SoupRouterState. REST and GraphQL lists share this reader;
    // only email mutations and their reply loader use the writer service, so
    // normal list traffic never switches to the primary.
    let soup_service = Arc::new(
        SoupImpl::new(
            PgSoupRepo::new(readonly_pool::ReadOnlyPool(readonly_db.clone())),
            frecency_service,
            readonly_email_service.clone(),
            ChannelListServiceImpl::new(
                PgChannelsRepo::new(readonly_db.clone()),
                PgChannelsRepo::new(readonly_db.clone()),
                frecency_storage.clone(),
            )
            .with_agent_dm_profiles(Arc::new(
                outbound::agent_dm_authorizer::AgentDmProfileReader::new(
                    PgChannelsRepo::new(readonly_db.clone()),
                    PgBotsRepo::new(readonly_db.clone()),
                ),
            )),
            call::domain::service::CallRecordQueryServiceImpl::new(PgCallRepo::new(
                readonly_db.clone(),
            )),
            crm_service.clone(),
            GithubPullRequestServiceImpl::new(
                ForeignEntityServiceImpl::new(PgForeignEntityRepo::new(readonly_db.clone())),
                PgGithubPullRequestRepo::new(readonly_db.clone()),
            ),
        )
        .with_favorites(favorites_service.clone())
        .with_agent_branches(agent_changes::outbound::postgres::PgChangesetRepo::new(
            readonly_db.clone(),
        )),
    );

    let websocket_notification_consumer_service =
        Arc::new(WebSocketNotificationConsumerService::new(
            NotificationTopicConsumer::<model_notifications::NotifEvent>::from_env(
                config.kafka_brokers.as_ref(),
            )
            .map_err(|error| {
                anyhow::anyhow!("failed to create WebSocket notification topic consumer: {error:?}")
            })?,
        ));
    consumer_tracker.spawn({
        let service = Arc::clone(&websocket_notification_consumer_service);
        let cancellation_token = consumer_cancellation_token.clone();
        async move {
            loop {
                let result = tokio::select! {
                    biased;
                    _ = cancellation_token.cancelled() => break,
                    result = service.run() => result,
                };

                if cancellation_token.is_cancelled() {
                    break;
                }

                let _ = result.inspect_err(|error| {
                    tracing::error!(
                        error = ?error,
                        "WebSocket notification consumer stopped"
                    );
                });

                tokio::select! {
                    biased;
                    _ = cancellation_token.cancelled() => break,
                    _ = tokio::time::sleep(Duration::from_secs(1)) => {}
                }
            }
        }
    });

    let activity_realtime_service = Arc::new(activity::ActivityRealtimeConsumerService::new(
        activity::ActivityTopicConsumer::from_env(config.kafka_brokers.as_ref()).map_err(
            |error| anyhow::anyhow!("failed to create realtime activity topic consumer: {error:?}"),
        )?,
    ));
    consumer_tracker.spawn({
        let service = Arc::clone(&activity_realtime_service);
        let cancellation_token = consumer_cancellation_token.clone();
        async move {
            loop {
                let result = tokio::select! {
                    biased;
                    _ = cancellation_token.cancelled() => break,
                    result = service.run() => result,
                };

                if cancellation_token.is_cancelled() {
                    break;
                }

                let _ = result.inspect_err(|error| {
                    tracing::error!(
                        error = ?error,
                        "realtime activity subscription consumer stopped"
                    );
                });

                tokio::select! {
                    biased;
                    _ = cancellation_token.cancelled() => break,
                    _ = tokio::time::sleep(Duration::from_secs(1)) => {}
                }
            }
        }
    });

    let soup_realtime_service = Arc::new(SoupRealtimeConsumerService::new(
        SoupTopicConsumer::from_env(config.kafka_brokers.as_ref()).map_err(|error| {
            anyhow::anyhow!("failed to create realtime Soup topic consumer: {error:?}")
        })?,
    ));
    consumer_tracker.spawn({
        let soup_realtime_service = Arc::clone(&soup_realtime_service);
        let cancellation_token = consumer_cancellation_token.clone();
        async move {
            loop {
                let result = tokio::select! {
                    biased;
                    _ = cancellation_token.cancelled() => break,
                    result = soup_realtime_service.run() => result,
                };

                if cancellation_token.is_cancelled() {
                    break;
                }

                let _ = result.inspect_err(|error| {
                    tracing::error!(
                        error = ?error,
                        "realtime Soup subscription consumer stopped"
                    );
                });

                tokio::select! {
                    biased;
                    _ = cancellation_token.cancelled() => break,
                    _ = tokio::time::sleep(Duration::from_secs(1)) => {}
                }
            }
        }
    });

    // Reads the harness' agent session log stream through a consumer group of
    // this process' own, and fans each run out to GraphQL log subscribers.
    let agent_session_log_realtime = Arc::new(AgentSessionLogConsumerService::new(
        RedisLogStreamConsumer::connect(redis_client.clone())
            .await
            .map_err(|error| {
                anyhow::anyhow!("failed to create agent session log stream consumer: {error:?}")
            })?,
    ));
    consumer_tracker.spawn({
        let service = Arc::clone(&agent_session_log_realtime);
        let cancellation_token = consumer_cancellation_token.clone();
        async move {
            loop {
                let result = tokio::select! {
                    biased;
                    _ = cancellation_token.cancelled() => break,
                    result = service.run() => result,
                };

                if cancellation_token.is_cancelled() {
                    break;
                }

                let _ = result.inspect_err(|error| {
                    tracing::error!(
                        error = ?error,
                        "agent session log subscription consumer stopped"
                    );
                });

                tokio::select! {
                    biased;
                    _ = cancellation_token.cancelled() => break,
                    _ = tokio::time::sleep(Duration::from_secs(1)) => {}
                }
            }
            // Nothing reads this process' group once it stops.
            let _ = service.consumer().close().await.inspect_err(|error| {
                tracing::warn!(
                    error = ?error,
                    "failed to close the agent session log stream consumer group"
                );
            });
        }
    });

    consumer_tracker.spawn({
        let session_repo = agent_session::outbound::postgres::PgAgentSessionRepo::new(
            db.clone(),
            owned_entity_registrar.clone(),
        );
        let brokers = config.kafka_brokers.as_ref().to_string();
        let entity_access_service = entity_access_service.as_ref().clone();
        let macro_event_broker = macro_event_broker.clone();
        let cancellation_token = consumer_cancellation_token.clone();
        async move {
            let mut consecutive_failures = 0_u32;
            loop {
                if cancellation_token.is_cancelled() {
                    break;
                }

                let fanout_service = SoupRealtimeServiceImpl::new(
                    EntityAccessExpander::new(entity_access_service.clone()),
                    KafkaSoupRealtimePublisher::new(macro_event_broker.clone()),
                );
                tracing::info!("starting realtime Soup entity consumer");
                let result = fanout_service
                    .run_entity_update_consumer(
                        &brokers,
                        &soup_realtime::outbound::agent_sessions::AgentSessionPullRequestLookup(
                            session_repo.clone(),
                        ),
                        cancellation_token.cancelled(),
                    )
                    .await;

                if cancellation_token.is_cancelled() {
                    break;
                }

                let restart_delay = match result {
                    Ok(()) => {
                        consecutive_failures = 0;
                        tracing::error!("realtime Soup entity consumer exited unexpectedly");
                        soup_consumer_restart_delay(1)
                    }
                    Err(error) => {
                        consecutive_failures = consecutive_failures.saturating_add(1);
                        let restart_delay = soup_consumer_restart_delay(consecutive_failures);
                        if consecutive_failures >= SOUP_CONSUMER_RESTART_ALERT_THRESHOLD {
                            tracing::error!(
                                error = ?error,
                                consecutive_failures,
                                restart_delay_secs = restart_delay.as_secs(),
                                "realtime Soup entity consumer repeatedly failed"
                            );
                        } else {
                            tracing::warn!(
                                error = ?error,
                                consecutive_failures,
                                restart_delay_secs = restart_delay.as_secs(),
                                "realtime Soup entity consumer failed; scheduling restart"
                            );
                        }
                        restart_delay
                    }
                };

                tokio::select! {
                    biased;
                    _ = cancellation_token.cancelled() => break,
                    _ = tokio::time::sleep(restart_delay) => {}
                }
            }
        }
    });

    let favorites_mutation_service = Arc::new(FavoritesMutationServiceImpl::new(
        favorites_service.clone(),
        entity_access_service.clone(),
    ));
    let account_manager_service = Arc::new(AccountManagerServiceImpl::new(
        PgAccountManagerRepo::new(db.clone()),
        DmAccountManagerDelivery::new(
            channels_service.clone(),
            message_commands.clone(),
            entity_access_service.clone(),
            macro_service_urls::AppServiceUrl::new()?,
        ),
    ));
    let user_api_key_service = Arc::new(UserApiKeyServiceImpl::new(PgUserApiKeysRepo::new(
        db.clone(),
    )));
    // The GraphQL own-calendar feed reads the primary, like the REST calendar
    // routes: a `refresh_calendar` poke goes out as the write commits, and the
    // delta it triggers would find nothing on a lagging replica, leaving the
    // change unseen until some later poke. Range reads share the pool so a
    // page cannot overwrite what a delta already applied with older rows.
    let calendar_read_service = Arc::new(calendar_events::domain::service::CalendarService::new(
        calendar_events::outbound::pg::PgCalendarRepository::new(db.clone()),
    ));
    let graphql_calendar_context = graphql_calendar::CalendarGraphqlContext::new(
        calendar_read_service.clone(),
        Arc::new(
            calendar_events::domain::changes::CalendarChangeService::new(
                calendar_events::outbound::pg::PgCalendarRepository::new(db.clone()),
            ),
        ),
    );
    // Team policy reads use the primary so a sharing downgrade cannot be
    // served from a lagging replica.
    let calendar_state = CalendarRouterState::new(
        Arc::new(
            calendar_events::domain::service::CalendarService::new(
                calendar_events::outbound::pg::PgCalendarRepository::new(db.clone()),
            )
            .with_team_sharing_enabled(config.calendar_team_sharing_enabled),
        ),
        authorization_state.clone(),
    );
    // Join requests write, so they use the primary like the team policy reads.
    let calendar_join_request_state =
        calendar_events::inbound::join_request_router::CalendarJoinRequestRouterState::new(
            Arc::new(
                calendar_events::domain::join_requests::CalendarJoinRequestServiceImpl::new(
                    calendar_events::outbound::pg::PgCalendarRepository::new(db.clone()),
                    calendar_events::outbound::notification_notifier::NotificationCalendarJoinRequestNotifier::new(
                        (*notification_ingress_service).clone(),
                    ),
                    crate::outbound::calendar_refresh::ConnectionGatewayCalendarRefresh::new(
                        (*conn_gateway_client).clone(),
                        db.clone(),
                        event_broker_tracker.clone(),
                    ),
                ),
            ),
            authorization_state.clone(),
        );
    // Calendar writes belong to calendar_service; each GraphQL mutation then
    // answers from the primary so it reads the state its write committed.
    let graphql_calendar_mutation_context = graphql_calendar::CalendarGraphqlMutationContext::new(
        Arc::new(
            calendar_events::outbound::calendar_service_mutations::CalendarServiceMutations::new(
                macro_service_urls::CalendarServiceUrl::new()
                    .context("calendar service url")?
                    .to_string(),
                config.internal_api_key.to_string(),
            ),
        ),
        Arc::new(
            calendar_events::domain::changes::CalendarChangeService::new(
                calendar_events::outbound::pg::PgCalendarRepository::new(db.clone()),
            ),
        ),
    );

    // Reminder dispatch. An EventBridge rule drops a sweep tick on this queue
    // every minute; the sweep fans one message out per due firing, onto the
    // same queue, and every task in the pool delivers them in parallel.
    let reminder_dispatch_worker = {
        let queue = SqsDispatchQueue::new(
            aws_sdk_sqs::Client::new(&aws_config),
            reminder_dispatch_queue.to_string(),
        );
        let dispatch_service = ReminderDispatchService::new(
            PgRemindersRepo::new(db.clone()),
            NotificationReminderNotifier::new((*notification_ingress_service).clone()),
            queue.clone(),
        );
        DispatchWorker::new(
            reminders::domain::email_followup::dispatch::EmailReminderDispatch::new(
                dispatch_service,
                email_followups.clone(),
            ),
            queue,
        )
    };

    consumer_tracker.spawn({
        let cancellation_token = consumer_cancellation_token.clone();
        async move {
            tracing::info!("starting reminder dispatch worker");
            reminder_dispatch_worker.run(cancellation_token).await;
            tracing::info!("reminder dispatch worker stopped");
        }
    });

    // Calendar event reminder dispatch: same sweep/deliver shape as reminders,
    // on its own queue. Behind a master switch — when off, the worker drains
    // the minutely tick so the queue neither backs up nor dead-letters.
    let calendar_reminder_dispatch_worker = {
        let queue = SqsCalendarDispatchQueue::new(
            aws_sdk_sqs::Client::new(&aws_config),
            calendar_reminder_dispatch_queue.to_string(),
        );
        let dispatch_service = CalendarReminderDispatchService::new(
            calendar_events::outbound::pg::PgCalendarRepository::new(db.clone()),
            NotificationCalendarReminderNotifier::new((*notification_ingress_service).clone()),
            queue.clone(),
        );
        CalendarReminderDispatchWorker::new(dispatch_service, queue)
    };

    consumer_tracker.spawn({
        let cancellation_token = consumer_cancellation_token.clone();
        let enabled = config.calendar_reminder_dispatch_enabled;
        async move {
            if enabled {
                tracing::info!("starting calendar reminder dispatch worker");
                calendar_reminder_dispatch_worker
                    .run(cancellation_token)
                    .await;
                tracing::info!("calendar reminder dispatch worker stopped");
            } else {
                tracing::info!("calendar reminder dispatch disabled; draining its queue");
                calendar_reminder_dispatch_worker
                    .drain(cancellation_token)
                    .await;
            }
        }
    });

    let redis_sha_client = Arc::new(Redis::new(redis_client));

    let document_purger = Arc::new(documents_hex::domain::purge::DocumentPurger::new(
        documents_hex::outbound::document_purge::LegacyDocumentPurgeRepository::new(db.clone()),
        documents_hex::outbound::document_purge::SqsDocumentPurgeQueue::new(sqs_client.clone()),
        documents_hex::outbound::document_purge::RedisDocxPartReferences::new(
            redis_sha_client.clone(),
        ),
        macro_event_broker.clone(),
    ));

    let owned_purge_state = DssOwnedPurgeState::new(
        document_purger.clone(),
        Arc::new(
            chat::domain::service::ChatServiceImpl::new_without_tools(
                chat::outbound::postgres::PgChatRepo::new(
                    db.clone(),
                    owned_entity_registrar.clone(),
                ),
                entity_access_management_service.clone(),
            )
            .with_event_broker(macro_event_broker.clone()),
        ),
        project_service.clone(),
    );

    let graphql_entity_mutation_service =
        Arc::new(service::entity_mutation::DssEntityMutationService::new(
            document_service.clone(),
            chat_mutation_service,
            channels_service.clone(),
            call_service.clone(),
            Arc::new(email_service.clone()),
            project_service.clone(),
            databases_service.clone(),
            forms_service.clone(),
            entity_access_service.clone(),
            Arc::new(outbound::entity_mutation::DssEntityLifecycleAdapter::new(
                db.clone(),
                redis_sha_client.clone(),
                sqs_client.clone(),
                macro_event_broker.clone(),
            )),
        ));

    // Routine writes still use the scheduled-action service. Read from the
    // primary pool here so the GraphQL list cannot restore stale state after
    // a REST write.
    let scheduled_action_read_service = Arc::new(ScheduledActionReadServiceImpl::new(
        Arc::new(PgScheduledActionRepo::new(
            db.clone(),
            owned_entity_registrar.clone(),
        )),
        entity_access_service.clone(),
    ));

    // Attention feeds (Home's work feed and the notifications inbox) share
    // one feed layer and these adapters: Soup
    // candidates over the replica, notification acknowledgement on the
    // primary, and live updates recomputed from the viewer's notification,
    // activity and Soup streams. Done publishes a viewer-addressed Soup patch
    // so the viewer's other sessions recompute too: GraphQL notification
    // writes publish no realtime update.
    let feed_triggers: Arc<dyn attention_feed::domain::ports::FeedTriggers> = Arc::new(
        attention_feed::outbound::triggers::RealtimeFeedTriggers::new(
            websocket_notification_consumer_service.clone(),
            activity_realtime_service.clone(),
            soup_realtime_service.clone(),
        ),
    );
    let feed_viewers: Arc<dyn attention_feed::inbound::viewers::FeedViewerResolver> = Arc::new(
        attention_feed::inbound::viewers::EntityAccessFeedViewers(entity_access_service.clone()),
    );
    // Reads the primary: a client refetches right after the change it heard about.
    let graphql_registered_work_context = complete_graph::RegisteredWorkGraphqlContext::new(
        agent_session::domain::work_registration::WorkRegistrationService::new(
            agent_session::outbound::postgres::PgAgentSessionRepo::new(
                db.clone(),
                owned_entity_registrar.clone(),
            ),
            Arc::new(
                agent_session::domain::audience::EntityAccessSessionView::new(
                    entity_access_service.as_ref().clone(),
                ),
            ),
            agent_session::domain::work_registration::NoWorkRegistrationSignal,
        ),
        soup_realtime_service.clone(),
    );
    let graphql_work_feed_context = complete_graph::WorkFeedGraphqlContext::new(
        work_feed::domain::service::WorkFeedServiceImpl::new(
            attention_feed::outbound::soup::SoupCandidateSource::new(
                soup_service.clone(),
                Arc::new(email_service.clone()),
            ),
            attention_feed::outbound::notifications::ReaderFeedNotifications::new(
                graphql_notification_reader.clone(),
            ),
            attention_feed::outbound::mail::EmailFeedMail::new(Arc::new(email_service.clone())),
            attention_feed::outbound::signals::SoupRealtimeFeedSignals::new(
                KafkaSoupRealtimePublisher::new(macro_event_broker.clone()),
            ),
        ),
        feed_triggers.clone(),
        feed_viewers.clone(),
    );
    let graphql_notification_inbox_context = complete_graph::NotificationInboxGraphqlContext::new(
        notification_inbox::domain::service::NotificationInboxServiceImpl::new(
            attention_feed::outbound::soup::SoupCandidateSource::new(
                soup_service.clone(),
                Arc::new(email_service.clone()),
            ),
            attention_feed::outbound::notifications::ReaderFeedNotifications::new(
                graphql_notification_reader.clone(),
            ),
            attention_feed::outbound::mail::EmailFeedMail::new(Arc::new(email_service.clone())),
            attention_feed::outbound::signals::SoupRealtimeFeedSignals::new(
                KafkaSoupRealtimePublisher::new(macro_event_broker.clone()),
            ),
        ),
        feed_triggers,
        feed_viewers,
    );

    let sync_sessions =
        sync_router::session::SyncSessionFactory::new(SyncServiceUrl::new()?.as_ref().parse()?)?;
    let api_context = ApiContext {
        sync_sessions,
        dictation_state,
        graphql_work_feed_context,
        graphql_registered_work_context,
        graphql_notification_inbox_context,
        contacts_ingress: contacts_ingress.clone(),
        soup_router_state: SoupRouterState::from_arc(
            soup_service.clone(),
            email_service.clone(),
            entity_access_service.clone(),
            authorization_state.clone(),
        )
        .with_favorites_reader(Arc::new(
            service::soup_favorites_reader::DssSoupFavoritesReader(favorites_service.clone()),
        )),
        favorites_state: FavoritesRouterState::new(
            favorites_service.clone(),
            entity_access_service.clone(),
            authorization_state.clone(),
        ),
        favorites_service,
        favorites_mutation_service,
        channel_labels_state: ChannelLabelsRouterState::new(
            Arc::new(ChannelLabelsServiceImpl::new(PgChannelLabelsRepo::new(
                db.clone(),
            ))),
            entity_access_service.clone(),
            authorization_state.clone(),
        ),
        account_manager_state: AccountManagerRouterState::new(
            account_manager_service,
            authorization_state.clone(),
        ),
        user_api_key_state: UserApiKeyRouterState::new(
            user_api_key_service,
            authorization_state.clone(),
        ),
        slack_state,
        external_chat_state,
        reminders_state: RemindersRouterState::new(
            Arc::new(reminders_service),
            entity_access_service.clone(),
            authorization_state.clone(),
        ),
        access_requests_state: access_requests::inbound::axum_router::AccessRequestsRouterState {
            service: access_requests_service,
            authorization_state: authorization_state.clone(),
        },
        graphql_initiative_entity_loader: graphql_initiative::InitiativeEntityLoader(
            graphql_soup::soup_item_loader(
                primary_entity_soup.clone(),
                Arc::new(email_service.clone()),
                entity_access_service.as_ref().clone(),
            ),
        ),
        graphql_agent_session_entity_loader: graphql_soup::AgentSessionEntityLoader::new(
            primary_entity_soup.clone(),
            Arc::new(email_service.clone()),
            entity_access_service.as_ref().clone(),
        ),
        graphql_database_rows_context: graphql_databases::DatabaseRowsGraphqlContext::new(
            databases_sql::view_rows::DatabaseViewRows::new(
                databases_service.clone(),
                databases::outbound::pg_view_rows::PgViewRows::new(db.clone()),
            ),
            entity_access_service.clone(),
            graphql_soup::soup_item_loader(
                primary_entity_soup.clone(),
                Arc::new(email_service.clone()),
                entity_access_service.as_ref().clone(),
            ),
        ),
        graphql_primary_soup_item_loader: graphql_soup::PrimarySoupItemLoader::new(
            primary_entity_soup,
            Arc::new(email_service.clone()),
            entity_access_service.as_ref().clone(),
        ),
        // Ordinary single-entity GraphQL reads use the replica-backed Soup
        // and email readers. Subscription hydration, `soupEntity`, and
        // mutation replies above read the primary.
        graphql_soup_item_loader: graphql_soup::soup_item_loader_with_team_access(
            soup_service.clone(),
            Arc::new(readonly_email_service),
            entity_access_service.as_ref().clone(),
        ),
        email_focus_reader: Arc::new(email::domain::focus::FocusQueries::new(
            email::outbound::FocusPgRepository(readonly_db.clone()),
        )),
        graphql_crm_context: graphql_crm::CrmGraphqlContext::new(pipeline_service.clone()),
        graphql_initiative_context: graphql_initiative::InitiativeGraphqlContext::new(
            initiative_service.clone(),
            entity_access_service.clone(),
        ),
        graphql_scheduled_action_context: ScheduledActionGraphqlContext::new(
            scheduled_action_read_service,
        ),
        graphql_calendar_context,
        graphql_calendar_mutation_context,
        initiative_state: InitiativeRouterState::new(
            initiative_service,
            entity_access_service.clone(),
            authorization_state.clone(),
        ),
        sql_state: databases_sql::inbound::axum_router::SqlRouterState::new(
            sql_service,
            authorization_state.clone(),
        ),
        databases_state: databases::inbound::axum_router::DatabasesRouterState::new(
            databases_service,
            entity_access_service.clone(),
            authorization_state.clone(),
        ),
        database_webhooks_state:
            database_webhooks::inbound::axum_router::DatabaseWebhooksRouterState::new(
                database_webhooks_service,
                entity_access_service.clone(),
                authorization_state.clone(),
            ),
        forms_state: forms::inbound::axum_router::FormsRouterState::new(
            forms_service,
            entity_access_service.clone(),
            authorization_state.clone(),
        ),
        database_starter_state: databases::inbound::starter_router::DatabaseStarterRouterState::new(
            Arc::new(databases::domain::starter::DatabaseStarterServiceImpl::new(
                databases::outbound::pg_starter::PgDatabaseStarterRepo::new(
                    db.clone(),
                    properties::outbound::properties_pg_repo::PropertiesPgRepo::new(db.clone()),
                ),
                macro_event_broker.clone(),
            )),
            authorization_state.clone(),
        ),
        collab_surface_state: CollabSurfaceRouterState::new(
            collab_surface_service,
            entity_access_service.clone(),
            authorization_state.clone(),
        ),
        graphql_soup_schema: complete_graph::build_schema_from_arcs(
            soup_service,
            soup_realtime_service,
            websocket_notification_consumer_service,
            activity_realtime_service,
        ),
        agent_session_log_subscriptions: complete_graph::agent_session_log_subscriptions(
            agent_session_log_realtime,
        ),
        graphql_notification_reader,
        // GraphQL reads the activity log through the readonly pool; the
        // Kafka consumer's writer-pool repo above is separate on purpose.
        activity_reader: complete_graph::ActivityPortReader::new(Arc::new(
            initiative::domain::personal_activity::ProjectVisibleActivityReads::new(
                activity::outbound::pg_activity_repo::PgActivityRepo::new(readonly_db.clone()),
                entity_access_service.clone(),
            ),
        )),
        graphql_entity_mutation_service,
        github_sync_service: Arc::new(github_sync_service_impl),
        github_pull_request_index_state,
        github_pull_request_state,
        github_pull_request_changes_state,
        foreign_entity_state,
        db: db.clone(),
        readonly_db: readonly_pool::ReadOnlyPool(readonly_db.clone()),
        redis_client: redis_sha_client,
        s3_client: s3,
        dynamodb_client: Arc::new(dynamodb_client),
        dynamo_db,
        macro_event_broker: macro_event_broker.clone(),
        sqs_client: sqs_client.clone(),
        document_purger,
        notification_ingress_service: notification_ingress_service.clone(),
        conn_gateway_client: conn_gateway_client.clone(),
        sync_service_client: sync_service_client.clone(),
        system_properties_service: system_properties_service.clone(),
        properties_service: properties_service.clone(),
        opensearch_client: Arc::new(opensearch_client),
        authorization_state: authorization_state.clone(),
        jwt_validation_args,
        dss_auth_key,
        // Shared frecency storage and legacy channel list routes.
        frecency_storage,
        channel_list_state,
        entity_access_service: entity_access_service.clone(),
        calendar_state,
        calendar_join_request_state,
        projects_state: ProjectRouterState {
            service: project_service,
            access_service: entity_access_service.clone(),
            authorization_state: authorization_state.clone(),
            non_user_owners,
        },
        documents_state: DocumentRouterState {
            service: document_service,
            access_service: entity_access_service.clone(),
            authorization_state: authorization_state.clone(),
            pool: db.clone(),
            task_dedup_service,
            lexical_client: lexical_client.clone(),
            creator: document_creator,
            ai_editing: document_ai_editing,
            presentations: Arc::new(
                documents_hex::domain::presentation::PresentationService::new(
                    document_files.clone(),
                ),
            ),
            word_documents,
            designs: Arc::new(documents_hex::domain::design::DesignService::new(
                document_files.clone(),
            )),
            photoshop_documents: Arc::new(documents_hex::domain::photoshop::PhotoshopService::new(
                document_files.clone(),
            )),
            illustrator_documents: Arc::new(
                documents_hex::domain::illustrator::IllustratorService::new(document_files),
            ),
            document_permission_jwt_secret: config.document_permission_jwt.as_ref().to_string(),
            non_user_owners,
        },
        config: Arc::new(config),
        channel_service: channels_service.clone(),
        channels_state: ChannelsRouterState::from_arc(
            channels_service,
            (*entity_access_service).clone(),
            authorization_state.clone(),
        ),
        messages_state,
        guest_chat_service,
        annotation_service,
        bots_state: bots::inbound::axum_router::BotsRouterState::new(
            bots_service.clone(),
            (*entity_access_service).clone(),
            authorization_state.clone(),
        ),
        harnesses_state: harnesses::inbound::axum_router::HarnessesRouterState::new(
            harnesses_service,
            authorization_state.clone(),
        ),
        channel_bot_webhook_state,
        call_state,
        call_webhook_state,
        call_public_rate_limiter,
        webhook_state,
        sse_stream_state,
        call_internal_state,
        cal_webhook_state,
        entity_access_management_service,
        pipeline_state: crm::inbound::pipelines::PipelineRouterState {
            service: pipeline_service,
            access: entity_access_service.clone(),
            authorization: authorization_state.clone(),
        },
        crm_state: crm::inbound::axum_router::CrmRouterState {
            service: Arc::new(crm_service),
            stage_service: Arc::new(crm::domain::stages::CrmStageServiceImpl::new(
                crm::outbound::companies_repo::CompaniesRepositoryImpl::new(db.clone()),
                crm::outbound::stage_definitions::PropertiesStageDefinitionStore::new(
                    properties_service.clone(),
                ),
            )),
            entity_access_service: entity_access_service.clone(),
            authorization_state: authorization_state.clone(),
        },
        owned_purge_state,
    };

    #[cfg(feature = "delete_document_worker")]
    {
        let editing_worker_client = Arc::new(
            documents_hex::outbound::editing_worker_client::ReqwestEditingWorkerClient::from_url(
                AiEditingWorkerUrl::new()?.to_string(),
            )
            .with_internal_auth_key(Some(api_context.config.internal_api_key.to_string())),
        );

        // Spawn the delete document worker.
        let delete_worker_ctx = service::delete_document_worker::DeleteDocumentWorkerContext {
            worker: Arc::new(delete_document_worker),
            db: db.clone(),
            s3_client: api_context.s3_client.clone(),
            redis_client: api_context.redis_client.clone(),
            sync_service_client: api_context.sync_service_client.clone(),
            editing_worker_client,
            properties_service: api_context.properties_service.clone(),
        };

        tokio::spawn(async move {
            service::delete_document_worker::run_worker(delete_worker_ctx).await;
        });
    }

    let server_result = api::setup_and_serve(api_context).await;

    tracing::info!("stopping event consumers");
    consumer_cancellation_token.cancel();
    consumer_tracker.close();
    consumer_tracker.wait().await;
    tracing::info!("event consumers stopped");

    // Running imports stop at their next checkpoint and hand their runs over.
    import_jobs.hand_over().await;

    tracing::info!("waiting for event broker publishes to drain");
    event_broker_tracker.close();
    match tokio::time::timeout(EVENT_BROKER_DRAIN_TIMEOUT, event_broker_tracker.wait()).await {
        Ok(()) => tracing::info!("event broker publishes drained"),
        Err(error) => {
            tracing::warn!(
                error=?error,
                timeout_seconds = EVENT_BROKER_DRAIN_TIMEOUT.as_secs(),
                "timed out waiting for event broker publishes to drain"
            );
        }
    }

    server_result
}

const EVENT_BROKER_DRAIN_TIMEOUT: Duration = Duration::from_secs(10);