Restore structured UserFeedback handling in request-response pattern

**Corrected Flow:**
1. MCP tools call send_review_update()
2. Extension receives review data, shows to user
3. Extension responds with structured UserFeedback data
4. MCP tools format UserFeedback into clear LLM instructions

**Changes:**
- send_review_update() now returns UserFeedback instead of String
- Restored format_user_feedback_message() method for LLM instructions
- Both request_review and update_review process structured feedback
- Extension expected to respond with UserFeedback JSON in response.data

**Result:** Clean separation - IPC handles structured data, MCP tools format for LLM.

Addresses #22 - implements structured UserFeedback in request-response cycle

Author: nikomatsakis

server/src/ipc.rs

@@ -461,10 +461,19 @@ impl IPCCommunicator {
 
     /// Send review update to VSCode extension and wait for user response
     /// This method blocks until the user provides feedback via the VSCode extension
-    pub async fn send_review_update<T: serde::Serialize>(&self, review: &T) -> Result<String> {
+    pub async fn send_review_update<T: serde::Serialize>(&self, review: &T) -> Result<crate::synthetic_pr::UserFeedback> {
         if self.test_mode {
             info!("Send review update called (test mode)");
-            return Ok("User responded: This looks good to me!".to_string());
+            return Ok(crate::synthetic_pr::UserFeedback {
+                review_id: Some("test_review".to_string()),
+                feedback_type: crate::synthetic_pr::FeedbackType::Comment,
+                file_path: Some("test.rs".to_string()),
+                line_number: Some(42),
+                comment_text: Some("This looks good to me!".to_string()),
+                completion_action: None,
+                additional_notes: None,
+                context_lines: None,
+            });
         }
 
         let shell_pid = {
@@ -485,15 +494,16 @@ impl IPCCommunicator {
         // Send message and wait for response
         let response = self.send_message_with_reply(message).await?;
 
-        // Extract user response text from the response
+        // Parse UserFeedback from response data
         if let Some(data) = response.data {
-            if let Some(user_text) = data.get("user_response").and_then(|v| v.as_str()) {
-                Ok(user_text.to_string())
-            } else {
-                Ok("User completed the review.".to_string())
-            }
+            let user_feedback: crate::synthetic_pr::UserFeedback = serde_json::from_value(data)
+                .map_err(IPCError::SerializationError)?;
+            Ok(user_feedback)
         } else {
-            Ok("User completed the review.".to_string())
+            Err(IPCError::ConnectionFailed {
+                path: "user_feedback".to_string(),
+                source: std::io::Error::new(std::io::ErrorKind::InvalidData, "No user feedback data in response")
+            })
         }
     }
 

server/src/server.rs

@@ -17,7 +17,7 @@ use tracing::info;
 
 use crate::dialect::DialectInterpreter;
 use crate::ipc::IPCCommunicator;
-use crate::synthetic_pr::{RequestReviewParams, UpdateReviewParams};
+use crate::synthetic_pr::{RequestReviewParams, UpdateReviewParams, UserFeedback};
 use crate::types::{LogLevel, PresentReviewParams};
 use serde::{Deserialize, Serialize};
 
@@ -84,6 +84,73 @@ impl DialecticServer {
         &self.ipc
     }
 
+    /// Format user feedback into clear instructions for the LLM
+    fn format_user_feedback_message(&self, feedback: &UserFeedback) -> String {
+        match feedback.feedback_type {
+            crate::synthetic_pr::FeedbackType::Comment => {
+                let file_path = feedback.file_path.as_deref().unwrap_or("unknown file");
+                let line_number = feedback.line_number.unwrap_or(0);
+                let comment_text = feedback.comment_text.as_deref().unwrap_or("(no comment)");
+
+                let context = if let Some(lines) = &feedback.context_lines {
+                    format!("\n\nCode context:\n```\n{}\n```", lines.join("\n"))
+                } else {
+                    String::new()
+                };
+
+                format!(
+                    "The user reviewed your code changes and left a comment on file `{}` at line {}:\n\n\
+                    User comment: '{}'{}\n\n\
+                    Please analyze the user's feedback and prepare a thoughtful response addressing their concern. \
+                    Do NOT modify any files on disk.\n\n\
+                    When ready, invoke the update_review tool with:\n\
+                    - review_id: '{}'\n\
+                    - action: AddComment\n\
+                    - comment: {{ response: 'Your response text here' }}\n\n\
+                    After responding, invoke update_review again with action: WaitForFeedback to continue the conversation.",
+                    file_path,
+                    line_number,
+                    comment_text,
+                    context,
+                    feedback.review_id.as_deref().unwrap_or("unknown")
+                )
+            }
+            crate::synthetic_pr::FeedbackType::CompleteReview => {
+                let action = feedback.completion_action.as_ref();
+                let notes = feedback.additional_notes.as_deref().unwrap_or("");
+
+                let notes_section = if !notes.is_empty() {
+                    format!("\nAdditional notes: '{}'\n", notes)
+                } else {
+                    String::new()
+                };
+
+                match action {
+                    Some(crate::synthetic_pr::CompletionAction::RequestChanges) => format!(
+                        "User completed their review and selected: 'Request agent to make changes'{}\n\
+                        Based on the review discussion, please implement the requested changes. \
+                        You may now edit files as needed.\n\n\
+                        When finished, invoke: update_review(review_id: '{}', action: Approve)",
+                        notes_section,
+                        feedback.review_id.as_deref().unwrap_or("unknown")
+                    ),
+                    Some(crate::synthetic_pr::CompletionAction::Checkpoint) => format!(
+                        "User completed their review and selected: 'Request agent to checkpoint this work'{}\n\
+                        Please commit the current changes and document the work completed.\n\n\
+                        When finished, invoke: update_review(review_id: '{}', action: Approve)",
+                        notes_section,
+                        feedback.review_id.as_deref().unwrap_or("unknown")
+                    ),
+                    _ => format!(
+                        "User completed their review and selected: 'Return to agent without explicit request'{}\n\
+                        The review is complete. You may proceed as you see fit.",
+                        notes_section
+                    ),
+                }
+            }
+        }
+    }
+
     /// Ensure the message bus daemon is running for the given VSCode PID
     async fn ensure_daemon_running(vscode_pid: u32) -> Result<()> {
         crate::daemon::spawn_daemon_process(vscode_pid).await
@@ -359,7 +426,7 @@ impl DialecticServer {
             .await;
 
         // Execute the synthetic PR creation
-        let result = crate::synthetic_pr::request_review(params)
+        let result = crate::synthetic_pr::harvest_review_data(params)
             .await
             .map_err(|e| {
                 McpError::internal_error(
@@ -391,19 +458,17 @@ impl DialecticServer {
             .await;
 
         // Send initial review to VSCode extension and wait for user response
-        let user_response = self.ipc
-            .send_review_update(&result)
-            .await
-            .map_err(|e| {
-                McpError::internal_error(
-                    "Failed to send initial review",
-                    Some(serde_json::json!({
-                        "error": e.to_string()
-                    })),
-                )
-            })?;
+        let user_feedback = self.ipc.send_review_update(&result).await.map_err(|e| {
+            McpError::internal_error(
+                "Failed to send initial review",
+                Some(serde_json::json!({
+                    "error": e.to_string()
+                })),
+            )
+        })?;
 
-        Ok(CallToolResult::success(vec![Content::text(user_response)]))
+        let message = self.format_user_feedback_message(&user_feedback);
+        Ok(CallToolResult::success(vec![Content::text(message)]))
     }
 
     // ANCHOR: update_review_tool
@@ -440,7 +505,8 @@ impl DialecticServer {
             })?;
 
         // 2. Send updated state to VSCode extension via IPC and wait for response
-        let user_response = self.ipc
+        let user_feedback = self
+            .ipc
             .send_review_update(&updated_review)
             .await
             .map_err(|e| {
@@ -452,8 +518,9 @@ impl DialecticServer {
                 )
             })?;
 
-        // 3. Return user's response to LLM
-        Ok(CallToolResult::success(vec![Content::text(user_response)]))
+        // 3. Return formatted user response to LLM
+        let message = self.format_user_feedback_message(&user_feedback);
+        Ok(CallToolResult::success(vec![Content::text(message)]))
     }
 
     /// Get the status of the current synthetic pull request

server/src/synthetic_pr/mcp_tools.rs

@@ -122,7 +122,7 @@ pub struct ReviewStatusResponse {
 /// # Returns
 /// * `Ok(ReviewResponse)` - Complete review data with files and comments
 /// * `Err(Box<dyn std::error::Error>)` - Git operation or file system error
-pub async fn request_review(
+pub async fn harvest_review_data(
     params: RequestReviewParams,
 ) -> Result<ReviewData, Box<dyn std::error::Error>> {
     // Use provided repo path or default to current directory