feat: Add phase_guard for contract phase transitions

Implement phase_guard logic in the advance_phase tool. When a contract
has phase_guard enabled, the phase transition now:

1. Asks for user confirmation before advancing
2. Allows users to request changes to phase deliverables
3. Passes feedback to the task without advancing if changes requested

Changes:
- Add phase_guard field to Contract model and CreateContractRequest
- Add PhaseTransitionRequest, PhaseFileInfo, PhaseTaskInfo structs
- Update ChangePhaseRequest with confirmed and feedback fields
- Update ContractToolRequest::AdvancePhase with confirmed/feedback
- Modify advance_phase handling in contract_chat.rs with phase_guard logic
- Update change_phase endpoint in contracts.rs with phase_guard support
- Add database migration for phase_guard column

When phase_guard=false: Phase advances immediately (current behavior)
When phase_guard=true: Returns pending_confirmation status with deliverables
If user provides feedback: Returns feedback to task, doesn't advance

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

1 files changed, 99 insertions, 13 deletions

diff --git a/makima/src/server/handlers/contracts.rs b/makima/src/server/handlers/contracts.rs
index 684ab2b..4f4a94b 100644
--- a/makima/src/server/handlers/contracts.rs
+++ b/makima/src/server/handlers/contracts.rs
@@ -1267,14 +1267,100 @@ pub async fn change_phase(
             .into_response();
     };
 
+    // First, get the contract to check phase_guard
+    let contract = match repository::get_contract_for_owner(pool, id, auth.owner_id).await {
+        Ok(Some(c)) => c,
+        Ok(None) => {
+            return (
+                StatusCode::NOT_FOUND,
+                Json(ApiError::new("NOT_FOUND", "Contract not found")),
+            )
+                .into_response();
+        }
+        Err(e) => {
+            tracing::error!("Failed to get contract {}: {}", id, e);
+            return (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                Json(ApiError::new("DB_ERROR", e.to_string())),
+            )
+                .into_response();
+        }
+    };
+
+    // If phase_guard is enabled and not confirmed, return phase deliverables for review
+    if contract.phase_guard && !req.confirmed.unwrap_or(false) {
+        // If user provided feedback, return it
+        if let Some(ref feedback) = req.feedback {
+            return Json(serde_json::json!({
+                "status": "changes_requested",
+                "currentPhase": contract.phase,
+                "requestedPhase": req.phase,
+                "feedback": feedback,
+                "message": "Feedback has been noted. Address the changes and try again."
+            }))
+            .into_response();
+        }
+
+        // Get files created in this phase
+        let phase_files = match repository::list_files_in_contract(pool, id, auth.owner_id).await {
+            Ok(files) => files
+                .into_iter()
+                .filter(|f| f.contract_phase.as_deref() == Some(&contract.phase))
+                .map(|f| serde_json::json!({
+                    "id": f.id,
+                    "name": f.name,
+                    "description": f.description
+                }))
+                .collect::<Vec<_>>(),
+            Err(_) => Vec::new(),
+        };
+
+        // Get tasks completed in this contract
+        let phase_tasks = match repository::list_tasks_in_contract(pool, id, auth.owner_id).await {
+            Ok(tasks) => tasks
+                .into_iter()
+                .filter(|t| t.status == "done" || t.status == "completed")
+                .map(|t| serde_json::json!({
+                    "id": t.id,
+                    "name": t.name,
+                    "status": t.status
+                }))
+                .collect::<Vec<_>>(),
+            Err(_) => Vec::new(),
+        };
+
+        let deliverables_summary = format!(
+            "Phase '{}' deliverables: {} files created, {} tasks completed.",
+            contract.phase,
+            phase_files.len(),
+            phase_tasks.len()
+        );
+
+        let transition_id = uuid::Uuid::new_v4().to_string();
+
+        return Json(serde_json::json!({
+            "status": "pending_confirmation",
+            "transitionId": transition_id,
+            "currentPhase": contract.phase,
+            "nextPhase": req.phase,
+            "deliverablesSummary": deliverables_summary,
+            "phaseFiles": phase_files,
+            "phaseTasks": phase_tasks,
+            "requiresConfirmation": true,
+            "message": "Phase transition requires confirmation. Set confirmed=true in the request to proceed."
+        }))
+        .into_response();
+    }
+
+    // Phase guard is disabled or user confirmed - proceed with phase change
     match repository::change_contract_phase_for_owner(pool, id, auth.owner_id, &req.phase).await {
-        Ok(Some(contract)) => {
+        Ok(Some(updated_contract)) => {
             // Notify supervisor of phase change
-            if let Some(supervisor_task_id) = contract.supervisor_task_id {
+            if let Some(supervisor_task_id) = updated_contract.supervisor_task_id {
                 if let Ok(Some(supervisor)) = repository::get_task_for_owner(pool, supervisor_task_id, auth.owner_id).await {
                     let state_clone = state.clone();
-                    let contract_id = contract.id;
-                    let new_phase = contract.phase.clone();
+                    let contract_id = updated_contract.id;
+                    let new_phase = updated_contract.phase.clone();
                     tokio::spawn(async move {
                         state_clone.notify_supervisor_of_phase_change(
                             supervisor.id,
@@ -1302,21 +1388,21 @@ pub async fn change_phase(
             ).await;
 
             // Get summary with counts
-            match repository::get_contract_summary_for_owner(pool, contract.id, auth.owner_id).await
+            match repository::get_contract_summary_for_owner(pool, updated_contract.id, auth.owner_id).await
             {
                 Ok(Some(summary)) => Json(summary).into_response(),
                 _ => Json(ContractSummary {
-                    id: contract.id,
-                    name: contract.name,
-                    description: contract.description,
-                    contract_type: contract.contract_type,
-                    phase: contract.phase,
-                    status: contract.status,
+                    id: updated_contract.id,
+                    name: updated_contract.name,
+                    description: updated_contract.description,
+                    contract_type: updated_contract.contract_type,
+                    phase: updated_contract.phase,
+                    status: updated_contract.status,
                     file_count: 0,
                     task_count: 0,
                     repository_count: 0,
-                    version: contract.version,
-                    created_at: contract.created_at,
+                    version: updated_contract.version,
+                    created_at: updated_contract.created_at,
                 })
                 .into_response(),
             }