fix(#247): address additional code review feedback

Fixes:
- Fix FK constraint violations: delete from task_dependencies, test_results,
  correction_attempts before deleting tasks
- Make delete_project_tasks_and_issues atomic with single transaction
- Follow repository pattern: delegate to TaskRepository.delete_all_project_tasks
  and IssueRepository.delete_all_project_issues
- Fix isRestarting not cleared on success in performRestartDiscovery

The delete operation now:
1. Uses _sync_lock for thread safety
2. Deletes all FK-dependent rows before tasks
3. Uses a shared cursor for atomic transaction
4. Commits only after all operations succeed (or rolls back on error)

Author: Test User

codeframe/persistence/database.py

@@ -720,9 +720,15 @@ def delete_discovery_answers(self, *args, **kwargs):
         return self.activities.delete_discovery_answers(*args, **kwargs)
 
     def delete_project_tasks_and_issues(self, project_id: int) -> dict:
-        """Delete all tasks and issues for a project.
+        """Delete all tasks and issues for a project atomically.
 
-        Performs cascading delete: tasks first (due to FK constraint), then issues.
+        Performs cascading delete in a single transaction:
+        1. Deletes task dependencies, test results, correction attempts
+        2. Deletes tasks (code_reviews and task_evidence cascade automatically)
+        3. Deletes issues
+
+        This method delegates to TaskRepository and IssueRepository for proper
+        separation of concerns and handles all FK constraints correctly.
 
         Args:
             project_id: Project ID
@@ -733,34 +739,34 @@ def delete_project_tasks_and_issues(self, project_id: int) -> dict:
         with self._sync_lock:
             cursor = self.conn.cursor()
 
-            # Count tasks before deletion
-            cursor.execute(
-                "SELECT COUNT(*) FROM tasks WHERE project_id = ?",
-                (project_id,),
-            )
-            task_count = cursor.fetchone()[0]
-
-            # Count issues before deletion
-            cursor.execute(
-                "SELECT COUNT(*) FROM issues WHERE project_id = ?",
-                (project_id,),
-            )
-            issue_count = cursor.fetchone()[0]
-
-            # Delete tasks first (due to FK constraint on issue_id)
-            cursor.execute(
-                "DELETE FROM tasks WHERE project_id = ?",
-                (project_id,),
-            )
-
-            # Then delete issues
-            cursor.execute(
-                "DELETE FROM issues WHERE project_id = ?",
-                (project_id,),
-            )
-
-            self.conn.commit()
-            return {"tasks": task_count, "issues": issue_count}
+            try:
+                # Count before deletion for return value
+                cursor.execute(
+                    "SELECT COUNT(*) FROM tasks WHERE project_id = ?",
+                    (project_id,),
+                )
+                task_count = cursor.fetchone()[0]
+
+                cursor.execute(
+                    "SELECT COUNT(*) FROM issues WHERE project_id = ?",
+                    (project_id,),
+                )
+                issue_count = cursor.fetchone()[0]
+
+                # Delete tasks first with all FK dependencies (single transaction)
+                # Pass cursor to avoid intermediate commits
+                self.tasks.delete_all_project_tasks(project_id, cursor=cursor)
+
+                # Then delete issues
+                self.issues.delete_all_project_issues(project_id, cursor=cursor)
+
+                # Commit the entire operation atomically
+                self.conn.commit()
+                return {"tasks": task_count, "issues": issue_count}
+
+            except Exception:
+                self.conn.rollback()
+                raise
 
     def create_audit_log(self, *args, **kwargs):
         """Delegate to audit_logs.create_audit_log()."""

codeframe/persistence/repositories/issue_repository.py

@@ -465,3 +465,38 @@ def get_issue_completion_status(self, issue_id: int) -> Dict[str, Any]:
             "completion_percentage": completion_percentage,
         }
 
+    def delete_all_project_issues(self, project_id: int, cursor: sqlite3.Cursor = None) -> int:
+        """Delete all issues for a project.
+
+        Note: Tasks must be deleted before issues due to FK constraints.
+        Use Database.delete_project_tasks_and_issues() for the complete
+        cascading delete operation.
+
+        Args:
+            project_id: Project ID to delete issues for
+            cursor: Optional cursor for transaction support. If provided,
+                    the caller is responsible for commit/rollback.
+
+        Returns:
+            Number of issues deleted
+        """
+        own_cursor = cursor is None
+        if own_cursor:
+            cursor = self.conn.cursor()
+
+        try:
+            cursor.execute(
+                "DELETE FROM issues WHERE project_id = ?",
+                (project_id,),
+            )
+            issue_count = cursor.rowcount
+
+            if own_cursor:
+                self.conn.commit()
+
+            return issue_count
+
+        except Exception:
+            if own_cursor:
+                self.conn.rollback()
+            raise

codeframe/persistence/repositories/task_repository.py

@@ -918,5 +918,77 @@ def _row_to_evidence(self, row: sqlite3.Row) -> "Evidence":
             verification_errors=verification_errors if verification_errors else None,
         )
 
+    def delete_all_project_tasks(self, project_id: int, cursor: sqlite3.Cursor = None) -> int:
+        """Delete all tasks for a project, handling FK constraints.
+
+        This method deletes all dependent records before deleting tasks:
+        - task_dependencies (both task_id and depends_on_task_id)
+        - test_results
+        - correction_attempts
+
+        Note: code_reviews and task_evidence have ON DELETE CASCADE and are handled
+        automatically by the database.
+
+        Args:
+            project_id: Project ID to delete tasks for
+            cursor: Optional cursor for transaction support. If provided,
+                    the caller is responsible for commit/rollback.
+
+        Returns:
+            Number of tasks deleted
+        """
+        own_cursor = cursor is None
+        if own_cursor:
+            cursor = self.conn.cursor()
+
+        try:
+            # Get all task IDs for this project
+            cursor.execute(
+                "SELECT id FROM tasks WHERE project_id = ?",
+                (project_id,),
+            )
+            task_ids = [row[0] for row in cursor.fetchall()]
+
+            if not task_ids:
+                return 0
+
+            # Create placeholders for IN clause
+            placeholders = ",".join("?" * len(task_ids))
+
+            # Delete from task_dependencies (both FK columns)
+            cursor.execute(
+                f"DELETE FROM task_dependencies WHERE task_id IN ({placeholders}) OR depends_on_task_id IN ({placeholders})",
+                task_ids + task_ids,
+            )
+
+            # Delete from test_results
+            cursor.execute(
+                f"DELETE FROM test_results WHERE task_id IN ({placeholders})",
+                task_ids,
+            )
+
+            # Delete from correction_attempts
+            cursor.execute(
+                f"DELETE FROM correction_attempts WHERE task_id IN ({placeholders})",
+                task_ids,
+            )
+
+            # Now delete the tasks (code_reviews and task_evidence cascade automatically)
+            cursor.execute(
+                "DELETE FROM tasks WHERE project_id = ?",
+                (project_id,),
+            )
+            task_count = cursor.rowcount
+
+            if own_cursor:
+                self.conn.commit()
+
+            return task_count
+
+        except Exception:
+            if own_cursor:
+                self.conn.rollback()
+            raise
+
     # Code Review CRUD operations (Sprint 10: 015-review-polish)
 

web-ui/src/components/DiscoveryProgress.tsx

@@ -288,6 +288,7 @@ const DiscoveryProgress = memo(function DiscoveryProgress({ projectId, onViewPRD
       setShowRestartConfirmation(false);
       setConfirmationData(null);
       setWaitingForQuestionStart(null);
+      setIsRestarting(false);
       fetchProgress();
     } catch (err) {
       console.error('Failed to restart discovery:', err);