feat: add learning proposal review flow

src/apps/desktop/src/api/learning_proposal_api.rs

@@ -0,0 +1,105 @@
+use bitfun_core::agentic::learning_proposals::{
+    get_learning_proposal_service, ApproveLearningProposalRequest, CreateLearningProposalRequest,
+    GetLearningProposalRequest, LearningProposal, ListLearningProposalsRequest,
+    RefreshLearningProposalRequest, RejectLearningProposalRequest,
+};
+use log::{error, info};
+
+#[tauri::command]
+pub async fn create_learning_proposal(
+    request: CreateLearningProposalRequest,
+) -> Result<LearningProposal, String> {
+    let session_id = request.session_id.clone();
+    let turn_id = request.source.turn_id.clone();
+    let result = get_learning_proposal_service().create(request).await;
+    match result {
+        Ok(proposal) => {
+            info!(
+                "Learning proposal created: proposal_id={}, session_id={}, turn_id={}, status={:?}",
+                proposal.proposal_id, session_id, turn_id, proposal.status
+            );
+            Ok(proposal)
+        }
+        Err(err) => {
+            error!(
+                "Failed to create learning proposal: session_id={}, turn_id={}, error={err}",
+                session_id, turn_id
+            );
+            Err(err.to_string())
+        }
+    }
+}
+
+#[tauri::command]
+pub async fn get_learning_proposal(
+    request: GetLearningProposalRequest,
+) -> Result<LearningProposal, String> {
+    get_learning_proposal_service()
+        .get(&request)
+        .await
+        .map_err(|err| err.to_string())
+}
+
+#[tauri::command]
+pub async fn list_learning_proposals(
+    request: ListLearningProposalsRequest,
+) -> Result<Vec<LearningProposal>, String> {
+    get_learning_proposal_service()
+        .list(&request)
+        .await
+        .map_err(|err| err.to_string())
+}
+
+#[tauri::command]
+pub async fn refresh_learning_proposal(
+    request: RefreshLearningProposalRequest,
+) -> Result<LearningProposal, String> {
+    let proposal_id = request.proposal_id.clone();
+    let result = get_learning_proposal_service().refresh(&request).await;
+    if let Err(err) = &result {
+        error!(
+            "Failed to refresh learning proposal: proposal_id={}, error={err}",
+            proposal_id
+        );
+    }
+    result.map_err(|err| err.to_string())
+}
+
+#[tauri::command]
+pub async fn approve_learning_proposal(
+    request: ApproveLearningProposalRequest,
+) -> Result<LearningProposal, String> {
+    let proposal_id = request.proposal_id.clone();
+    let result = get_learning_proposal_service().approve(&request).await;
+    match result {
+        Ok(proposal) => {
+            info!(
+                "Learning proposal approval handled: proposal_id={}, status={:?}",
+                proposal_id, proposal.status
+            );
+            Ok(proposal)
+        }
+        Err(err) => {
+            error!(
+                "Failed to approve learning proposal: proposal_id={}, error={err}",
+                proposal_id
+            );
+            Err(err.to_string())
+        }
+    }
+}
+
+#[tauri::command]
+pub async fn reject_learning_proposal(
+    request: RejectLearningProposalRequest,
+) -> Result<LearningProposal, String> {
+    let proposal_id = request.proposal_id.clone();
+    let result = get_learning_proposal_service().reject(&request).await;
+    if let Err(err) = &result {
+        error!(
+            "Failed to reject learning proposal: proposal_id={}, error={err}",
+            proposal_id
+        );
+    }
+    result.map_err(|err| err.to_string())
+}

src/apps/desktop/src/api/mod.rs

@@ -23,6 +23,7 @@ pub mod git_agent_api;
 pub mod git_api;
 pub mod i18n_api;
 pub mod insights_api;
+pub mod learning_proposal_api;
 pub mod lsp_api;
 pub mod lsp_workspace_api;
 pub mod mcp_api;

src/apps/desktop/src/lib.rs

@@ -1371,6 +1371,13 @@ pub async fn run() {
             api::insights_api::load_insights_report,
             api::insights_api::has_insights_data,
             api::insights_api::cancel_insights_generation,
+            // Learning Proposal API
+            api::learning_proposal_api::create_learning_proposal,
+            api::learning_proposal_api::get_learning_proposal,
+            api::learning_proposal_api::list_learning_proposals,
+            api::learning_proposal_api::refresh_learning_proposal,
+            api::learning_proposal_api::approve_learning_proposal,
+            api::learning_proposal_api::reject_learning_proposal,
             // SSH Remote API
             api::ssh_api::ssh_list_saved_connections,
             api::ssh_api::ssh_save_connection,

src/crates/assembly/core/Cargo.toml

@@ -31,6 +31,7 @@ chrono = { workspace = true }
 chrono-tz = { workspace = true, optional = true }
 cron = { workspace = true, optional = true }
 regex = { workspace = true }
+pulldown-cmark = { workspace = true, optional = true }
 base64 = { workspace = true }
 image = { workspace = true, optional = true }
 md5 = { workspace = true, optional = true }
@@ -200,6 +201,7 @@ plugin-source = [
 product-domains = [
     "ai-adapter-runtime",
     "dep:bitfun-product-domains",
+    "dep:pulldown-cmark",
     "plugin-source",
     "bitfun-services-integrations/function-agents",
     "bitfun-services-integrations/miniapp-runtime",