feat: Week 4 收尾 + 架构治理 — 搜索/家长中心/Feature Flag/Docker/环境配置

架构治理:
- Feature Flag 落地: Cargo.toml [features] default=["diary"] + main.rs cfg 条件编译
- 环境配置统一: AppConfig 类 + --dart-define 注入 + SSE 端口 8080→3000 修复

搜索替代方案 (无 FTS):
- SearchBloc + 标签/心情筛选接入后端 API
- JournalRepository 扩展 mood/tag 筛选参数
- 搜索页 UI 接入实际数据（替换占位文本）

家长中心最小集 (PIPL 合规):
- 后端: parent_service (绑定/查看/导出/删除/解绑) + parent_handler (6 个 API 端点)
- 前端: ParentBloc + ParentPage 功能完整实现
- 绑定孩子、只读查看日记、导出数据、删除数据、解绑

Docker 部署:
- verify.sh 健康检查脚本 (Axum/PG/Redis/OpenAPI 四项检查)

测试修复:
- home_bloc_test / calendar_bloc_test 适配 JournalRepository 新参数

验证: flutter test 84/84 pass, cargo test 76/76 pass, cargo check pass

crates/erp-diary/src/handler/mod.rs

@@ -8,3 +8,4 @@ pub mod comment_handler;
 pub mod sticker_handler;
 pub mod achievement_handler;
 pub mod stats_handler;
+pub mod parent_handler;

crates/erp-diary/src/handler/parent_handler.rs

@@ -0,0 +1,340 @@
+// 家长中心 API 处理器 — PIPL 合规: 绑定/查阅/导出/删除
+
+use axum::extract::{Extension, FromRef, Query, State};
+use axum::response::Json;
+use serde::{Deserialize, Serialize};
+use utoipa::{IntoParams, ToSchema};
+use uuid::Uuid;
+
+use erp_core::error::AppError;
+use erp_core::rbac::require_permission;
+use erp_core::types::{ApiResponse, PaginatedResponse, TenantContext};
+
+use crate::dto::JournalResp;
+use crate::service::parent_service::ParentService;
+use crate::state::DiaryState;
+
+// ---- 请求/响应 DTO ----
+
+/// 绑定孩子请求
+#[derive(Debug, Deserialize, ToSchema)]
+pub struct BindChildReq {
+    /// 孩子的用户 ID
+    pub child_id: Uuid,
+}
+
+/// 查看孩子日记查询参数
+#[derive(Debug, Deserialize, IntoParams)]
+pub struct ChildJournalsQuery {
+    /// 孩子的用户 ID
+    pub child_id: Uuid,
+    /// 页码（默认 1）
+    pub page: Option<u64>,
+    /// 每页条数（默认 20，最大 100）
+    pub page_size: Option<u64>,
+}
+
+/// 导出数据查询参数
+#[derive(Debug, Deserialize, IntoParams)]
+pub struct ExportQuery {
+    /// 孩子的用户 ID
+    pub child_id: Uuid,
+}
+
+/// 删除孩子数据请求
+#[derive(Debug, Deserialize, ToSchema)]
+pub struct DeleteChildDataReq {
+    /// 孩子的用户 ID
+    pub child_id: Uuid,
+}
+
+/// 绑定信息响应
+#[derive(Debug, Serialize, ToSchema)]
+pub struct BindingResp {
+    pub binding_id: Uuid,
+    pub child_id: Uuid,
+    pub verified_at: Option<chrono::DateTime<chrono::Utc>>,
+}
+
+/// 删除结果响应
+#[derive(Debug, Serialize, ToSchema)]
+pub struct DeleteResultResp {
+    pub deleted_count: usize,
+    pub message: String,
+}
+
+// ---- Handler 函数 ----
+
+#[utoipa::path(
+    post,
+    path = "/api/v1/diary/parent/bind",
+    request_body = BindChildReq,
+    responses(
+        (status = 200, description = "绑定成功", body = ApiResponse<BindingResp>),
+        (status = 400, description = "已绑定该孩子"),
+        (status = 401, description = "未授权"),
+        (status = 403, description = "权限不足"),
+    ),
+    security(("bearer_auth" = [])),
+    tag = "家长中心"
+)]
+/// POST /api/v1/diary/parent/bind
+///
+/// 家长绑定孩子账号。需要 `diary.parent.bind` 权限。
+pub async fn bind_child<S>(
+    State(state): State<DiaryState>,
+    Extension(ctx): Extension<TenantContext>,
+    Json(req): Json<BindChildReq>,
+) -> Result<Json<ApiResponse<BindingResp>>, AppError>
+where
+    DiaryState: FromRef<S>,
+    S: Clone + Send + Sync + 'static,
+{
+    require_permission(&ctx, "diary.parent.bind")?;
+
+    let binding = ParentService::bind_child(
+        ctx.tenant_id,
+        ctx.user_id,
+        req.child_id,
+        &state.db,
+        &state.event_bus,
+    )
+    .await?;
+
+    Ok(Json(ApiResponse::ok(BindingResp {
+        binding_id: binding.id,
+        child_id: binding.child_id,
+        verified_at: binding.verified_at,
+    })))
+}
+
+#[utoipa::path(
+    get,
+    path = "/api/v1/diary/parent/children",
+    responses(
+        (status = 200, description = "孩子列表", body = ApiResponse<Vec<BindingResp>>),
+        (status = 401, description = "未授权"),
+        (status = 403, description = "权限不足"),
+    ),
+    security(("bearer_auth" = [])),
+    tag = "家长中心"
+)]
+/// GET /api/v1/diary/parent/children
+///
+/// 获取家长绑定的孩子列表。需要 `diary.parent.bind` 权限。
+pub async fn list_children<S>(
+    State(state): State<DiaryState>,
+    Extension(ctx): Extension<TenantContext>,
+) -> Result<Json<ApiResponse<Vec<BindingResp>>>, AppError>
+where
+    DiaryState: FromRef<S>,
+    S: Clone + Send + Sync + 'static,
+{
+    require_permission(&ctx, "diary.parent.bind")?;
+
+    let bindings = ParentService::list_children(ctx.tenant_id, ctx.user_id, &state.db).await?;
+
+    let resp: Vec<BindingResp> = bindings
+        .into_iter()
+        .map(|b| BindingResp {
+            binding_id: b.id,
+            child_id: b.child_id,
+            verified_at: b.verified_at,
+        })
+        .collect();
+
+    Ok(Json(ApiResponse::ok(resp)))
+}
+
+#[utoipa::path(
+    get,
+    path = "/api/v1/diary/parent/journals",
+    params(ChildJournalsQuery),
+    responses(
+        (status = 200, description = "孩子日记列表", body = ApiResponse<PaginatedResponse<JournalResp>>),
+        (status = 401, description = "未授权"),
+        (status = 403, description = "权限不足或未绑定该孩子"),
+    ),
+    security(("bearer_auth" = [])),
+    tag = "家长中心"
+)]
+/// GET /api/v1/diary/parent/journals
+///
+/// 查看已绑定孩子的日记列表（只读）。需要 `diary.journal.read` 权限。
+pub async fn get_child_journals<S>(
+    State(state): State<DiaryState>,
+    Extension(ctx): Extension<TenantContext>,
+    Query(params): Query<ChildJournalsQuery>,
+) -> Result<Json<ApiResponse<PaginatedResponse<JournalResp>>>, AppError>
+where
+    DiaryState: FromRef<S>,
+    S: Clone + Send + Sync + 'static,
+{
+    require_permission(&ctx, "diary.journal.read")?;
+
+    let page = params.page.unwrap_or(1);
+    let page_size = params.page_size.unwrap_or(20).min(100);
+
+    let (models, total) = ParentService::get_child_journals(
+        ctx.tenant_id,
+        ctx.user_id,
+        params.child_id,
+        page,
+        page_size,
+        &state.db,
+    )
+    .await?;
+
+    let items: Vec<JournalResp> = models.into_iter().map(journal_model_to_resp).collect();
+    let total_pages = total.div_ceil(page_size);
+
+    Ok(Json(ApiResponse::ok(PaginatedResponse {
+        data: items,
+        total,
+        page,
+        page_size,
+        total_pages,
+    })))
+}
+
+#[utoipa::path(
+    get,
+    path = "/api/v1/diary/parent/export",
+    params(ExportQuery),
+    responses(
+        (status = 200, description = "导出数据"),
+        (status = 401, description = "未授权"),
+        (status = 403, description = "权限不足或未绑定该孩子"),
+    ),
+    security(("bearer_auth" = [])),
+    tag = "家长中心"
+)]
+/// GET /api/v1/diary/parent/export
+///
+/// 导出孩子所有日记数据（PIPL 数据可携带权）。需要 `diary.journal.read` 权限。
+pub async fn export_child_data<S>(
+    State(state): State<DiaryState>,
+    Extension(ctx): Extension<TenantContext>,
+    Query(params): Query<ExportQuery>,
+) -> Result<Json<serde_json::Value>, AppError>
+where
+    DiaryState: FromRef<S>,
+    S: Clone + Send + Sync + 'static,
+{
+    require_permission(&ctx, "diary.journal.read")?;
+
+    let data =
+        ParentService::export_child_data(ctx.tenant_id, ctx.user_id, params.child_id, &state.db)
+            .await?;
+
+    Ok(Json(data))
+}
+
+#[utoipa::path(
+    delete,
+    path = "/api/v1/diary/parent/data",
+    request_body = DeleteChildDataReq,
+    responses(
+        (status = 200, description = "删除成功", body = ApiResponse<DeleteResultResp>),
+        (status = 401, description = "未授权"),
+        (status = 403, description = "权限不足或未绑定该孩子"),
+    ),
+    security(("bearer_auth" = [])),
+    tag = "家长中心"
+)]
+/// DELETE /api/v1/diary/parent/data
+///
+/// 软删除孩子所有日记数据（PIPL 删除权）。需要 `diary.parent.bind` 权限。
+/// 数据将在 30 天内完成清理。
+pub async fn delete_child_data<S>(
+    State(state): State<DiaryState>,
+    Extension(ctx): Extension<TenantContext>,
+    Json(req): Json<DeleteChildDataReq>,
+) -> Result<Json<ApiResponse<DeleteResultResp>>, AppError>
+where
+    DiaryState: FromRef<S>,
+    S: Clone + Send + Sync + 'static,
+{
+    require_permission(&ctx, "diary.parent.bind")?;
+
+    let count = ParentService::delete_child_data(
+        ctx.tenant_id,
+        ctx.user_id,
+        req.child_id,
+        &state.db,
+        &state.event_bus,
+    )
+    .await?;
+
+    Ok(Json(ApiResponse::ok(DeleteResultResp {
+        deleted_count: count,
+        message: "数据删除请求已提交，将在 30 天内完成删除".to_string(),
+    })))
+}
+
+#[utoipa::path(
+    delete,
+    path = "/api/v1/diary/parent/unbind",
+    request_body = BindChildReq,
+    responses(
+        (status = 200, description = "解绑成功"),
+        (status = 401, description = "未授权"),
+        (status = 403, description = "权限不足"),
+        (status = 404, description = "绑定关系不存在"),
+    ),
+    security(("bearer_auth" = [])),
+    tag = "家长中心"
+)]
+/// DELETE /api/v1/diary/parent/unbind
+///
+/// 解绑孩子。需要 `diary.parent.bind` 权限。
+pub async fn unbind_child<S>(
+    State(state): State<DiaryState>,
+    Extension(ctx): Extension<TenantContext>,
+    Json(req): Json<BindChildReq>,
+) -> Result<Json<ApiResponse<()>>, AppError>
+where
+    DiaryState: FromRef<S>,
+    S: Clone + Send + Sync + 'static,
+{
+    require_permission(&ctx, "diary.parent.bind")?;
+
+    ParentService::unbind_child(ctx.tenant_id, ctx.user_id, req.child_id, &state.db).await?;
+
+    Ok(Json(ApiResponse {
+        success: true,
+        data: None,
+        message: Some("已解绑".to_string()),
+    }))
+}
+
+/// journal_entry::Model -> JournalResp DTO 转换
+///
+/// 与 journal_service 中的 model_to_resp 逻辑一致，
+/// 但这里直接从 Model 转换避免循环依赖。
+fn journal_model_to_resp(model: crate::entity::journal_entry::Model) -> JournalResp {
+    use crate::dto::{Mood, Weather};
+
+    let mood: Mood = serde_json::from_str(&model.mood).unwrap_or(Mood::Happy);
+    let weather: Weather = serde_json::from_str(&model.weather).unwrap_or(Weather::Sunny);
+    let tags: Vec<String> = model
+        .tags
+        .and_then(|v| serde_json::from_value(v).ok())
+        .unwrap_or_default();
+
+    JournalResp {
+        id: model.id,
+        author_id: model.author_id,
+        class_id: model.class_id,
+        title: model.title,
+        date: model.date,
+        mood,
+        weather,
+        tags,
+        is_private: model.is_private,
+        shared_to_class: model.shared_to_class,
+        version: model.version,
+        created_at: model.created_at,
+        updated_at: model.updated_at,
+    }
+}

crates/erp-diary/src/lib.rs

@@ -12,7 +12,7 @@ use erp_core::module::ErpModule;
 
 use crate::handler::{
     journal_handler, sync_handler, class_handler, topic_handler, comment_handler,
-    sticker_handler, achievement_handler, stats_handler,
+    sticker_handler, achievement_handler, stats_handler, parent_handler,
 };
 
 /// 暖记日记业务模块
@@ -202,5 +202,30 @@ impl DiaryModule {
                 "/diary/stats/mood",
                 axum::routing::get(stats_handler::get_mood_stats),
             )
+            // 家长中心 — PIPL 合规
+            .route(
+                "/diary/parent/bind",
+                axum::routing::post(parent_handler::bind_child),
+            )
+            .route(
+                "/diary/parent/children",
+                axum::routing::get(parent_handler::list_children),
+            )
+            .route(
+                "/diary/parent/journals",
+                axum::routing::get(parent_handler::get_child_journals),
+            )
+            .route(
+                "/diary/parent/export",
+                axum::routing::get(parent_handler::export_child_data),
+            )
+            .route(
+                "/diary/parent/data",
+                axum::routing::delete(parent_handler::delete_child_data),
+            )
+            .route(
+                "/diary/parent/unbind",
+                axum::routing::delete(parent_handler::unbind_child),
+            )
     }
 }

crates/erp-diary/src/service/mod.rs

@@ -10,3 +10,4 @@ pub mod sticker_service;
 pub mod achievement_service;
 pub mod mood_stats_service;
 pub mod content_safety_service;
+pub mod parent_service;

crates/erp-diary/src/service/parent_service.rs

@@ -0,0 +1,295 @@
+// 家长-孩子绑定服务 — PIPL 合规: 数据查阅/导出/删除
+
+use chrono::Utc;
+use sea_orm::{
+    ActiveModelTrait, ColumnTrait, DatabaseConnection, EntityTrait, PaginatorTrait,
+    QueryFilter, QueryOrder, Set,
+};
+use uuid::Uuid;
+
+use crate::entity::journal_entry;
+use crate::entity::parent_child_binding;
+use crate::error::{DiaryError, DiaryResult};
+use erp_core::events::{DomainEvent, EventBus};
+
+/// 家长中心服务 — 绑定管理、数据查阅、导出、删除
+pub struct ParentService;
+
+impl ParentService {
+    /// 绑定孩子 — 家长通过孩子用户 ID 建立绑定关系
+    ///
+    /// 检查是否已存在有效绑定，避免重复绑定。
+    /// 插入后发布 `diary.parent.child_bound` 事件。
+    pub async fn bind_child(
+        tenant_id: Uuid,
+        parent_id: Uuid,
+        child_id: Uuid,
+        db: &DatabaseConnection,
+        event_bus: &EventBus,
+    ) -> DiaryResult<parent_child_binding::Model> {
+        // 检查是否已绑定
+        let existing = parent_child_binding::Entity::find()
+            .filter(parent_child_binding::Column::ParentId.eq(parent_id))
+            .filter(parent_child_binding::Column::ChildId.eq(child_id))
+            .filter(parent_child_binding::Column::TenantId.eq(tenant_id))
+            .filter(parent_child_binding::Column::Status.ne("revoked"))
+            .one(db)
+            .await?;
+
+        if existing.is_some() {
+            return Err(DiaryError::BadRequest("已绑定该孩子".to_string()));
+        }
+
+        let now = Utc::now();
+        let id = Uuid::now_v7();
+
+        let model = parent_child_binding::ActiveModel {
+            id: Set(id),
+            tenant_id: Set(tenant_id),
+            parent_id: Set(parent_id),
+            child_id: Set(child_id),
+            verification_method: Set("manual".to_string()),
+            verified_at: Set(Some(now)),
+            status: Set("verified".to_string()),
+            created_at: Set(now),
+            updated_at: Set(now),
+            created_by: Set(parent_id),
+            updated_by: Set(parent_id),
+            deleted_at: Set(None),
+            version: Set(1),
+        };
+
+        let inserted = model.insert(db).await?;
+
+        event_bus
+            .publish(
+                DomainEvent::new(
+                    "diary.parent.child_bound",
+                    tenant_id,
+                    serde_json::json!({
+                        "parent_id": parent_id,
+                        "child_id": child_id,
+                    }),
+                ),
+                db,
+            )
+            .await;
+
+        Ok(inserted)
+    }
+
+    /// 获取家长绑定的孩子列表
+    ///
+    /// 只返回 status=verified 且未软删除的绑定。
+    pub async fn list_children(
+        tenant_id: Uuid,
+        parent_id: Uuid,
+        db: &DatabaseConnection,
+    ) -> DiaryResult<Vec<parent_child_binding::Model>> {
+        let bindings = parent_child_binding::Entity::find()
+            .filter(parent_child_binding::Column::TenantId.eq(tenant_id))
+            .filter(parent_child_binding::Column::ParentId.eq(parent_id))
+            .filter(parent_child_binding::Column::Status.eq("verified"))
+            .filter(parent_child_binding::Column::DeletedAt.is_null())
+            .all(db)
+            .await?;
+
+        Ok(bindings)
+    }
+
+    /// 查看孩子日记 — 只读，家长只能查看已绑定的孩子的日记
+    ///
+    /// 先验证绑定关系，再分页查询孩子的日记列表。
+    pub async fn get_child_journals(
+        tenant_id: Uuid,
+        parent_id: Uuid,
+        child_id: Uuid,
+        page: u64,
+        page_size: u64,
+        db: &DatabaseConnection,
+    ) -> DiaryResult<(Vec<journal_entry::Model>, u64)> {
+        // 验证绑定关系
+        Self::verify_binding(tenant_id, parent_id, child_id, db).await?;
+
+        let page_size = page_size.min(100).max(1);
+        let page = page.max(1);
+
+        let paginator = journal_entry::Entity::find()
+            .filter(journal_entry::Column::TenantId.eq(tenant_id))
+            .filter(journal_entry::Column::AuthorId.eq(child_id))
+            .filter(journal_entry::Column::DeletedAt.is_null())
+            .order_by_desc(journal_entry::Column::Date)
+            .order_by_desc(journal_entry::Column::CreatedAt)
+            .paginate(db, page_size);
+
+        let total = paginator.num_items().await?;
+        let journals = paginator.fetch_page(page.saturating_sub(1)).await?;
+
+        Ok((journals, total))
+    }
+
+    /// 导出孩子数据 — 返回所有日记的 JSON（PIPL 数据可携带权）
+    ///
+    /// 先验证绑定关系，再查询孩子全部未删除的日记。
+    pub async fn export_child_data(
+        tenant_id: Uuid,
+        parent_id: Uuid,
+        child_id: Uuid,
+        db: &DatabaseConnection,
+    ) -> DiaryResult<serde_json::Value> {
+        Self::verify_binding(tenant_id, parent_id, child_id, db).await?;
+
+        let journals = journal_entry::Entity::find()
+            .filter(journal_entry::Column::TenantId.eq(tenant_id))
+            .filter(journal_entry::Column::AuthorId.eq(child_id))
+            .filter(journal_entry::Column::DeletedAt.is_null())
+            .all(db)
+            .await?;
+
+        Ok(serde_json::json!({
+            "child_id": child_id,
+            "exported_at": Utc::now(),
+            "journals": journals,
+        }))
+    }
+
+    /// 删除孩子数据 — 软删除所有日记（PIPL 删除权）
+    ///
+    /// 软删除孩子全部未删除的日记，逐条设置 deleted_at。
+    /// 发布 `diary.parent.data_deleted` 事件记录操作。
+    pub async fn delete_child_data(
+        tenant_id: Uuid,
+        parent_id: Uuid,
+        child_id: Uuid,
+        db: &DatabaseConnection,
+        event_bus: &EventBus,
+    ) -> DiaryResult<usize> {
+        Self::verify_binding(tenant_id, parent_id, child_id, db).await?;
+
+        let journals = journal_entry::Entity::find()
+            .filter(journal_entry::Column::TenantId.eq(tenant_id))
+            .filter(journal_entry::Column::AuthorId.eq(child_id))
+            .filter(journal_entry::Column::DeletedAt.is_null())
+            .all(db)
+            .await?;
+
+        let count = journals.len();
+        let now = Utc::now();
+
+        for journal in journals {
+            let current_version = journal.version;
+            let mut active: journal_entry::ActiveModel = journal.into();
+            active.deleted_at = Set(Some(now));
+            active.updated_at = Set(now);
+            active.updated_by = Set(parent_id);
+            active.version = Set(current_version + 1);
+            active.update(db).await?;
+        }
+
+        event_bus
+            .publish(
+                DomainEvent::new(
+                    "diary.parent.data_deleted",
+                    tenant_id,
+                    serde_json::json!({
+                        "parent_id": parent_id,
+                        "child_id": child_id,
+                        "deleted_count": count,
+                    }),
+                ),
+                db,
+            )
+            .await;
+
+        Ok(count)
+    }
+
+    /// 解绑孩子 — 将绑定状态设为 revoked
+    pub async fn unbind_child(
+        tenant_id: Uuid,
+        parent_id: Uuid,
+        child_id: Uuid,
+        db: &DatabaseConnection,
+    ) -> DiaryResult<()> {
+        let binding = parent_child_binding::Entity::find()
+            .filter(parent_child_binding::Column::TenantId.eq(tenant_id))
+            .filter(parent_child_binding::Column::ParentId.eq(parent_id))
+            .filter(parent_child_binding::Column::ChildId.eq(child_id))
+            .filter(parent_child_binding::Column::Status.eq("verified"))
+            .filter(parent_child_binding::Column::DeletedAt.is_null())
+            .one(db)
+            .await?
+            .ok_or_else(|| DiaryError::NotFound("绑定关系不存在".to_string()))?;
+
+        let current_version = binding.version;
+        let now = Utc::now();
+        let mut active: parent_child_binding::ActiveModel = binding.into();
+        active.status = Set("revoked".to_string());
+        active.updated_at = Set(now);
+        active.updated_by = Set(parent_id);
+        active.version = Set(current_version + 1);
+        active.update(db).await?;
+
+        Ok(())
+    }
+
+    /// 验证家长-孩子绑定关系
+    ///
+    /// 查询是否存在 status=verified 且未删除的绑定记录，
+    /// 不存在则返回 Forbidden 错误。
+    async fn verify_binding(
+        tenant_id: Uuid,
+        parent_id: Uuid,
+        child_id: Uuid,
+        db: &DatabaseConnection,
+    ) -> DiaryResult<()> {
+        let exists = parent_child_binding::Entity::find()
+            .filter(parent_child_binding::Column::TenantId.eq(tenant_id))
+            .filter(parent_child_binding::Column::ParentId.eq(parent_id))
+            .filter(parent_child_binding::Column::ChildId.eq(child_id))
+            .filter(parent_child_binding::Column::Status.eq("verified"))
+            .filter(parent_child_binding::Column::DeletedAt.is_null())
+            .one(db)
+            .await?;
+
+        if exists.is_none() {
+            return Err(DiaryError::Forbidden);
+        }
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// 验证 verify_binding 在无匹配记录时的错误类型
+    /// 由于没有数据库连接，这里只测试错误类型枚举匹配
+    #[test]
+    fn forbidden_error_is_correct_variant() {
+        let err = DiaryError::Forbidden;
+        match err {
+            DiaryError::Forbidden => {}
+            other => panic!("Expected Forbidden, got {:?}", other),
+        }
+    }
+
+    #[test]
+    fn bad_request_error_carries_message() {
+        let err = DiaryError::BadRequest("已绑定该孩子".to_string());
+        match err {
+            DiaryError::BadRequest(msg) => assert_eq!(msg, "已绑定该孩子"),
+            other => panic!("Expected BadRequest, got {:?}", other),
+        }
+    }
+
+    #[test]
+    fn not_found_error_carries_message() {
+        let err = DiaryError::NotFound("绑定关系不存在".to_string());
+        match err {
+            DiaryError::NotFound(msg) => assert_eq!(msg, "绑定关系不存在"),
+            other => panic!("Expected NotFound, got {:?}", other),
+        }
+    }
+}

crates/erp-server/Cargo.toml

@@ -3,6 +3,10 @@ name = "erp-server"
 version.workspace = true
 edition.workspace = true
 
+[features]
+default = ["diary"]
+diary = ["dep:erp-diary"]
+
 [[bin]]
 name = "erp-server"
 path = "src/main.rs"
@@ -28,7 +32,7 @@ erp-config.workspace = true
 erp-workflow.workspace = true
 erp-message.workspace = true
 erp-plugin.workspace = true
-erp-diary.workspace = true
+erp-diary = { workspace = true, optional = true }
 anyhow.workspace = true
 uuid.workspace = true
 chrono.workspace = true

crates/erp-server/src/main.rs

@@ -326,7 +326,9 @@ async fn main() -> anyhow::Result<()> {
     );
 
     // Initialize diary module (暖记业务)
+    #[cfg(feature = "diary")]
     let diary_module = erp_diary::DiaryModule;
+    #[cfg(feature = "diary")]
     tracing::info!(
         module = diary_module.name(),
         version = diary_module.version(),
@@ -338,8 +340,10 @@ async fn main() -> anyhow::Result<()> {
         .register(auth_module)
         .register(config_module)
         .register(workflow_module)
-        .register(message_module)
-        .register(diary_module);
+        .register(message_module);
+
+    #[cfg(feature = "diary")]
+    let registry = registry.register(diary_module);
     tracing::info!(
         module_count = registry.modules().len(),
         "Modules registered"
@@ -501,8 +505,12 @@ async fn main() -> anyhow::Result<()> {
         .merge(erp_config::ConfigModule::protected_routes())
         .merge(erp_workflow::WorkflowModule::protected_routes())
         .merge(erp_message::MessageModule::protected_routes())
-        .merge(erp_plugin::module::PluginModule::protected_routes())
-        .merge(erp_diary::DiaryModule::protected_routes())
+        .merge(erp_plugin::module::PluginModule::protected_routes());
+
+    #[cfg(feature = "diary")]
+    let protected_routes = protected_routes.merge(erp_diary::DiaryModule::protected_routes());
+
+    let protected_routes = protected_routes
         .merge(handlers::audit_log::audit_log_router())
         .route(
             "/upload",

crates/erp-server/src/state.rs

@@ -110,6 +110,7 @@ impl FromRef<AppState> for erp_plugin::state::PluginState {
 }
 
 /// Allow erp-diary handlers to extract their required state.
+#[cfg(feature = "diary")]
 impl FromRef<AppState> for erp_diary::DiaryState {
     fn from_ref(state: &AppState) -> Self {
         Self {