docs(job-queue-dependencies): add documentation for job queue setup and configuration

- Created a new document detailing the dependencies required for the job queue implementation using Bull and IORedis. - Included installation instructions, Redis setup, environment variable configuration, and usage examples for the RecurringTasksService. - Highlighted the benefits of using job queues over cron jobs and provided monitoring options for job queues.
feat(recurring-tasks): implement recurring tasks service with timezone support and notifications
2025-07-20 19:16:24 +05:30 · 2025-07-20 19:16:03 +05:30
40 changed files with 2771 additions and 5059 deletions
--- a/docs/job-queue-dependencies.md
+++ b/docs/job-queue-dependencies.md
@@ -0,0 +1,111 @@
+# Job Queue Dependencies
+
+To use the job queue implementation for recurring tasks, add these dependencies to your package.json:
+
+```json
+{
+  "dependencies": {
+    "bull": "^4.12.2",
+    "ioredis": "^5.3.2"
+  },
+  "devDependencies": {
+    "@types/bull": "^4.10.0"
+  }
+}
+```
+
+## Installation
+
+```bash
+npm install bull ioredis
+npm install --save-dev @types/bull
+```
+
+## Redis Setup
+
+1. Install Redis on your system:
+   - **Ubuntu/Debian**: `sudo apt install redis-server`
+   - **macOS**: `brew install redis`
+   - **Windows**: Use WSL or Redis for Windows
+   - **Docker**: `docker run -d -p 6379:6379 redis:alpine`
+
+2. Configure Redis connection in your environment variables:
+   ```env
+   REDIS_HOST=localhost
+   REDIS_PORT=6379
+   REDIS_PASSWORD=your_password  # Optional
+   REDIS_DB=0
+   ```
+
+## Configuration
+
+Add these environment variables to control the recurring tasks behavior:
+
+```env
+# Service configuration
+RECURRING_TASKS_ENABLED=true
+RECURRING_TASKS_MODE=queue  # or 'cron'
+
+# Queue configuration
+RECURRING_TASKS_MAX_CONCURRENCY=5
+RECURRING_TASKS_RETRY_ATTEMPTS=3
+RECURRING_TASKS_RETRY_DELAY=2000
+
+# Notifications
+RECURRING_TASKS_NOTIFICATIONS_ENABLED=true
+RECURRING_TASKS_EMAIL_NOTIFICATIONS=true
+RECURRING_TASKS_PUSH_NOTIFICATIONS=true
+RECURRING_TASKS_IN_APP_NOTIFICATIONS=true
+
+# Audit logging
+RECURRING_TASKS_AUDIT_LOG_ENABLED=true
+RECURRING_TASKS_AUDIT_RETENTION_DAYS=90
+```
+
+## Usage
+
+In your main application file, start the service:
+
+```typescript
+import { RecurringTasksService } from './src/services/recurring-tasks-service';
+
+// Start the service
+await RecurringTasksService.start();
+
+// Get status
+const status = await RecurringTasksService.getStatus();
+console.log('Recurring tasks status:', status);
+
+// Health check
+const health = await RecurringTasksService.healthCheck();
+console.log('Health check:', health);
+```
+
+## Benefits of Job Queue vs Cron
+
+### Job Queue (Bull/BullMQ) Benefits:
+- **Better scalability**: Can run multiple workers
+- **Retry logic**: Built-in retry with exponential backoff
+- **Monitoring**: Redis-based job monitoring and UI
+- **Priority queues**: Handle urgent tasks first
+- **Rate limiting**: Control processing rate
+- **Persistence**: Jobs survive server restarts
+
+### Cron Job Benefits:
+- **Simplicity**: No external dependencies
+- **Lower resource usage**: No Redis required
+- **Predictable timing**: Runs exactly on schedule
+- **Easier debugging**: Simpler execution model
+
+## Monitoring
+
+You can monitor the job queues using:
+- **Bull Dashboard**: Web UI for monitoring jobs
+- **Redis CLI**: Direct Redis monitoring
+- **Application logs**: Built-in audit logging
+- **Health checks**: Built-in health check endpoint
+
+Install Bull Dashboard for monitoring:
+```bash
+npm install -g bull-board
+```
--- a/package-lock.json
+++ b/package-lock.json
@@ -2,5 +2,385 @@
  "name": "worklenz",
  "lockfileVersion": 3,
  "requires": true,
-  "packages": {}
+  "packages": {
+    "": {
+      "dependencies": {
+        "bull": "^4.16.5",
+        "ioredis": "^5.6.1"
+      },
+      "devDependencies": {
+        "@types/bull": "^3.15.9"
+      }
+    },
+    "node_modules/@ioredis/commands": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/@ioredis/commands/-/commands-1.2.0.tgz",
+      "integrity": "sha512-Sx1pU8EM64o2BrqNpEO1CNLtKQwyhuXuqyfH7oGKCk+1a33d2r5saW8zNwm3j6BTExtjrv2BxTgzzkMwts6vGg==",
+      "license": "MIT"
+    },
+    "node_modules/@msgpackr-extract/msgpackr-extract-darwin-arm64": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/@msgpackr-extract/msgpackr-extract-darwin-arm64/-/msgpackr-extract-darwin-arm64-3.0.3.tgz",
+      "integrity": "sha512-QZHtlVgbAdy2zAqNA9Gu1UpIuI8Xvsd1v8ic6B2pZmeFnFcMWiPLfWXh7TVw4eGEZ/C9TH281KwhVoeQUKbyjw==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@msgpackr-extract/msgpackr-extract-darwin-x64": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/@msgpackr-extract/msgpackr-extract-darwin-x64/-/msgpackr-extract-darwin-x64-3.0.3.tgz",
+      "integrity": "sha512-mdzd3AVzYKuUmiWOQ8GNhl64/IoFGol569zNRdkLReh6LRLHOXxU4U8eq0JwaD8iFHdVGqSy4IjFL4reoWCDFw==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@msgpackr-extract/msgpackr-extract-linux-arm": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/@msgpackr-extract/msgpackr-extract-linux-arm/-/msgpackr-extract-linux-arm-3.0.3.tgz",
+      "integrity": "sha512-fg0uy/dG/nZEXfYilKoRe7yALaNmHoYeIoJuJ7KJ+YyU2bvY8vPv27f7UKhGRpY6euFYqEVhxCFZgAUNQBM3nw==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@msgpackr-extract/msgpackr-extract-linux-arm64": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/@msgpackr-extract/msgpackr-extract-linux-arm64/-/msgpackr-extract-linux-arm64-3.0.3.tgz",
+      "integrity": "sha512-YxQL+ax0XqBJDZiKimS2XQaf+2wDGVa1enVRGzEvLLVFeqa5kx2bWbtcSXgsxjQB7nRqqIGFIcLteF/sHeVtQg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@msgpackr-extract/msgpackr-extract-linux-x64": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/@msgpackr-extract/msgpackr-extract-linux-x64/-/msgpackr-extract-linux-x64-3.0.3.tgz",
+      "integrity": "sha512-cvwNfbP07pKUfq1uH+S6KJ7dT9K8WOE4ZiAcsrSes+UY55E/0jLYc+vq+DO7jlmqRb5zAggExKm0H7O/CBaesg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@msgpackr-extract/msgpackr-extract-win32-x64": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/@msgpackr-extract/msgpackr-extract-win32-x64/-/msgpackr-extract-win32-x64-3.0.3.tgz",
+      "integrity": "sha512-x0fWaQtYp4E6sktbsdAqnehxDgEc/VwM7uLsRCYWaiGu0ykYdZPiS8zCWdnjHwyiumousxfBm4SO31eXqwEZhQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@types/bull": {
+      "version": "3.15.9",
+      "resolved": "https://registry.npmjs.org/@types/bull/-/bull-3.15.9.tgz",
+      "integrity": "sha512-MPUcyPPQauAmynoO3ezHAmCOhbB0pWmYyijr/5ctaCqhbKWsjW0YCod38ZcLzUBprosfZ9dPqfYIcfdKjk7RNQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/ioredis": "*",
+        "@types/redis": "^2.8.0"
+      }
+    },
+    "node_modules/@types/ioredis": {
+      "version": "4.28.10",
+      "resolved": "https://registry.npmjs.org/@types/ioredis/-/ioredis-4.28.10.tgz",
+      "integrity": "sha512-69LyhUgrXdgcNDv7ogs1qXZomnfOEnSmrmMFqKgt1XMJxmoOSG/u3wYy13yACIfKuMJ8IhKgHafDO3sx19zVQQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/node": {
+      "version": "24.0.15",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-24.0.15.tgz",
+      "integrity": "sha512-oaeTSbCef7U/z7rDeJA138xpG3NuKc64/rZ2qmUFkFJmnMsAPaluIifqyWd8hSSMxyP9oie3dLAqYPblag9KgA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~7.8.0"
+      }
+    },
+    "node_modules/@types/redis": {
+      "version": "2.8.32",
+      "resolved": "https://registry.npmjs.org/@types/redis/-/redis-2.8.32.tgz",
+      "integrity": "sha512-7jkMKxcGq9p242exlbsVzuJb57KqHRhNl4dHoQu2Y5v9bCAbtIXXH0R3HleSQW4CTOqpHIYUW3t6tpUj4BVQ+w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/bull": {
+      "version": "4.16.5",
+      "resolved": "https://registry.npmjs.org/bull/-/bull-4.16.5.tgz",
+      "integrity": "sha512-lDsx2BzkKe7gkCYiT5Acj02DpTwDznl/VNN7Psn7M3USPG7Vs/BaClZJJTAG+ufAR9++N1/NiUTdaFBWDIl5TQ==",
+      "license": "MIT",
+      "dependencies": {
+        "cron-parser": "^4.9.0",
+        "get-port": "^5.1.1",
+        "ioredis": "^5.3.2",
+        "lodash": "^4.17.21",
+        "msgpackr": "^1.11.2",
+        "semver": "^7.5.2",
+        "uuid": "^8.3.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/cluster-key-slot": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/cluster-key-slot/-/cluster-key-slot-1.1.2.tgz",
+      "integrity": "sha512-RMr0FhtfXemyinomL4hrWcYJxmX6deFdCxpJzhDttxgO1+bcCnkk+9drydLVDmAMG7NE6aN/fl4F7ucU/90gAA==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/cron-parser": {
+      "version": "4.9.0",
+      "resolved": "https://registry.npmjs.org/cron-parser/-/cron-parser-4.9.0.tgz",
+      "integrity": "sha512-p0SaNjrHOnQeR8/VnfGbmg9te2kfyYSQ7Sc/j/6DtPL3JQvKxmjO9TSjNFpujqV3vEYYBvNNvXSxzyksBWAx1Q==",
+      "license": "MIT",
+      "dependencies": {
+        "luxon": "^3.2.1"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
+    "node_modules/debug": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/denque": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/denque/-/denque-2.1.0.tgz",
+      "integrity": "sha512-HVQE3AAb/pxF8fQAoiqpvg9i3evqug3hoiwakOyZAwJm+6vZehbkYXZ0l4JxS+I3QxM97v5aaRNhj8v5oBhekw==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
+    "node_modules/detect-libc": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.0.4.tgz",
+      "integrity": "sha512-3UDv+G9CsCKO1WKMGw9fwq/SWJYbI0c5Y7LU1AXYoDdbhE2AHQ6N6Nb34sG8Fj7T5APy8qXDCKuuIHd1BR0tVA==",
+      "license": "Apache-2.0",
+      "optional": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/get-port": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/get-port/-/get-port-5.1.1.tgz",
+      "integrity": "sha512-g/Q1aTSDOxFpchXC4i8ZWvxA1lnPqx/JHqcpIw0/LX9T8x/GBbi6YnlN5nhaKIFkT8oFsscUKgDJYxfwfS6QsQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/ioredis": {
+      "version": "5.6.1",
+      "resolved": "https://registry.npmjs.org/ioredis/-/ioredis-5.6.1.tgz",
+      "integrity": "sha512-UxC0Yv1Y4WRJiGQxQkP0hfdL0/5/6YvdfOOClRgJ0qppSarkhneSa6UvkMkms0AkdGimSH3Ikqm+6mkMmX7vGA==",
+      "license": "MIT",
+      "dependencies": {
+        "@ioredis/commands": "^1.1.1",
+        "cluster-key-slot": "^1.1.0",
+        "debug": "^4.3.4",
+        "denque": "^2.1.0",
+        "lodash.defaults": "^4.2.0",
+        "lodash.isarguments": "^3.1.0",
+        "redis-errors": "^1.2.0",
+        "redis-parser": "^3.0.0",
+        "standard-as-callback": "^2.1.0"
+      },
+      "engines": {
+        "node": ">=12.22.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/ioredis"
+      }
+    },
+    "node_modules/lodash": {
+      "version": "4.17.21",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
+      "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.defaults": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/lodash.defaults/-/lodash.defaults-4.2.0.tgz",
+      "integrity": "sha512-qjxPLHd3r5DnsdGacqOMU6pb/avJzdh9tFX2ymgoZE27BmjXrNy/y4LoaiTeAb+O3gL8AfpJGtqfX/ae2leYYQ==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isarguments": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/lodash.isarguments/-/lodash.isarguments-3.1.0.tgz",
+      "integrity": "sha512-chi4NHZlZqZD18a0imDHnZPrDeBbTtVN7GXMwuGdRH9qotxAjYs3aVLKc7zNOG9eddR5Ksd8rvFEBc9SsggPpg==",
+      "license": "MIT"
+    },
+    "node_modules/luxon": {
+      "version": "3.7.1",
+      "resolved": "https://registry.npmjs.org/luxon/-/luxon-3.7.1.tgz",
+      "integrity": "sha512-RkRWjA926cTvz5rAb1BqyWkKbbjzCGchDUIKMCUvNi17j6f6j8uHGDV82Aqcqtzd+icoYpELmG3ksgGiFNNcNg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/msgpackr": {
+      "version": "1.11.5",
+      "resolved": "https://registry.npmjs.org/msgpackr/-/msgpackr-1.11.5.tgz",
+      "integrity": "sha512-UjkUHN0yqp9RWKy0Lplhh+wlpdt9oQBYgULZOiFhV3VclSF1JnSQWZ5r9gORQlNYaUKQoR8itv7g7z1xDDuACA==",
+      "license": "MIT",
+      "optionalDependencies": {
+        "msgpackr-extract": "^3.0.2"
+      }
+    },
+    "node_modules/msgpackr-extract": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/msgpackr-extract/-/msgpackr-extract-3.0.3.tgz",
+      "integrity": "sha512-P0efT1C9jIdVRefqjzOQ9Xml57zpOXnIuS+csaB4MdZbTdmGDLo8XhzBG1N7aO11gKDDkJvBLULeFTo46wwreA==",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "node-gyp-build-optional-packages": "5.2.2"
+      },
+      "bin": {
+        "download-msgpackr-prebuilds": "bin/download-prebuilds.js"
+      },
+      "optionalDependencies": {
+        "@msgpackr-extract/msgpackr-extract-darwin-arm64": "3.0.3",
+        "@msgpackr-extract/msgpackr-extract-darwin-x64": "3.0.3",
+        "@msgpackr-extract/msgpackr-extract-linux-arm": "3.0.3",
+        "@msgpackr-extract/msgpackr-extract-linux-arm64": "3.0.3",
+        "@msgpackr-extract/msgpackr-extract-linux-x64": "3.0.3",
+        "@msgpackr-extract/msgpackr-extract-win32-x64": "3.0.3"
+      }
+    },
+    "node_modules/node-gyp-build-optional-packages": {
+      "version": "5.2.2",
+      "resolved": "https://registry.npmjs.org/node-gyp-build-optional-packages/-/node-gyp-build-optional-packages-5.2.2.tgz",
+      "integrity": "sha512-s+w+rBWnpTMwSFbaE0UXsRlg7hU4FjekKU4eyAih5T8nJuNZT1nNsskXpxmeqSK9UzkBl6UgRlnKc8hz8IEqOw==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "detect-libc": "^2.0.1"
+      },
+      "bin": {
+        "node-gyp-build-optional-packages": "bin.js",
+        "node-gyp-build-optional-packages-optional": "optional.js",
+        "node-gyp-build-optional-packages-test": "build-test.js"
+      }
+    },
+    "node_modules/redis-errors": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/redis-errors/-/redis-errors-1.2.0.tgz",
+      "integrity": "sha512-1qny3OExCf0UvUV/5wpYKf2YwPcOqXzkwKKSmKHiE6ZMQs5heeE/c8eXK+PNllPvmjgAbfnsbpkGZWy8cBpn9w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/redis-parser": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/redis-parser/-/redis-parser-3.0.0.tgz",
+      "integrity": "sha512-DJnGAeenTdpMEH6uAJRK/uiyEIH9WVsUmoLwzudwGJUwZPp80PDBWPHXSAGNPwNvIXAbe7MSUB1zQFugFml66A==",
+      "license": "MIT",
+      "dependencies": {
+        "redis-errors": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/semver": {
+      "version": "7.7.2",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz",
+      "integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==",
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/standard-as-callback": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/standard-as-callback/-/standard-as-callback-2.1.0.tgz",
+      "integrity": "sha512-qoRRSyROncaz1z0mvYqIE4lCd9p2R90i6GxW3uZv5ucSu8tU7B5HXUP1gG8pVZsYNVaXjk8ClXHPttLyxAL48A==",
+      "license": "MIT"
+    },
+    "node_modules/undici-types": {
+      "version": "7.8.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.8.0.tgz",
+      "integrity": "sha512-9UJ2xGDvQ43tYyVMpuHlsgApydB8ZKfVYTsLDhXkFL/6gfkp+U8xTGdh8pMJv1SpZna0zxG1DwsKZsreLbXBxw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/uuid": {
+      "version": "8.3.2",
+      "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz",
+      "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==",
+      "license": "MIT",
+      "bin": {
+        "uuid": "dist/bin/uuid"
+      }
+    }
+  }
 }
--- a/package.json
+++ b/package.json
@@ -0,0 +1,9 @@
+{
+  "dependencies": {
+    "bull": "^4.16.5",
+    "ioredis": "^5.6.1"
+  },
+  "devDependencies": {
+    "@types/bull": "^3.15.9"
+  }
+}
--- a/worklenz-backend/database/sql/functions/create_bulk_recurring_tasks.sql
+++ b/worklenz-backend/database/sql/functions/create_bulk_recurring_tasks.sql
@@ -0,0 +1,185 @@
+-- Function to create multiple recurring tasks in bulk
+CREATE OR REPLACE FUNCTION create_bulk_recurring_tasks(
+    p_tasks JSONB
+)
+RETURNS TABLE (
+    task_id UUID,
+    task_name TEXT,
+    created BOOLEAN,
+    error_message TEXT
+) AS $$
+DECLARE
+    v_task JSONB;
+    v_task_id UUID;
+    v_existing_id UUID;
+    v_error_message TEXT;
+BEGIN
+    -- Create a temporary table to store results
+    CREATE TEMP TABLE IF NOT EXISTS bulk_task_results (
+        task_id UUID,
+        task_name TEXT,
+        created BOOLEAN,
+        error_message TEXT
+    ) ON COMMIT DROP;
+
+    -- Iterate through each task in the array
+    FOR v_task IN SELECT * FROM jsonb_array_elements(p_tasks)
+    LOOP
+        BEGIN
+            -- Check if task already exists for this schedule and date
+            SELECT id INTO v_existing_id
+            FROM tasks
+            WHERE schedule_id = (v_task->>'schedule_id')::UUID
+              AND end_date::DATE = (v_task->>'end_date')::DATE
+            LIMIT 1;
+
+            IF v_existing_id IS NOT NULL THEN
+                -- Task already exists
+                INSERT INTO bulk_task_results (task_id, task_name, created, error_message)
+                VALUES (v_existing_id, v_task->>'name', FALSE, 'Task already exists for this date');
+            ELSE
+                -- Create the task using existing function
+                SELECT (create_quick_task(v_task::TEXT)::JSONB)->>'id' INTO v_task_id;
+                
+                IF v_task_id IS NOT NULL THEN
+                    INSERT INTO bulk_task_results (task_id, task_name, created, error_message)
+                    VALUES (v_task_id::UUID, v_task->>'name', TRUE, NULL);
+                ELSE
+                    INSERT INTO bulk_task_results (task_id, task_name, created, error_message)
+                    VALUES (NULL, v_task->>'name', FALSE, 'Failed to create task');
+                END IF;
+            END IF;
+            
+        EXCEPTION WHEN OTHERS THEN
+            -- Capture any errors
+            v_error_message := SQLERRM;
+            INSERT INTO bulk_task_results (task_id, task_name, created, error_message)
+            VALUES (NULL, v_task->>'name', FALSE, v_error_message);
+        END;
+    END LOOP;
+
+    -- Return all results
+    RETURN QUERY SELECT * FROM bulk_task_results;
+END;
+$$ LANGUAGE plpgsql;
+
+-- Function to bulk assign team members to tasks
+CREATE OR REPLACE FUNCTION bulk_assign_team_members(
+    p_assignments JSONB
+)
+RETURNS TABLE (
+    task_id UUID,
+    team_member_id UUID,
+    assigned BOOLEAN,
+    error_message TEXT
+) AS $$
+DECLARE
+    v_assignment JSONB;
+    v_result RECORD;
+BEGIN
+    CREATE TEMP TABLE IF NOT EXISTS bulk_assignment_results (
+        task_id UUID,
+        team_member_id UUID,
+        assigned BOOLEAN,
+        error_message TEXT
+    ) ON COMMIT DROP;
+
+    FOR v_assignment IN SELECT * FROM jsonb_array_elements(p_assignments)
+    LOOP
+        BEGIN
+            -- Check if assignment already exists
+            IF EXISTS (
+                SELECT 1 FROM tasks_assignees
+                WHERE task_id = (v_assignment->>'task_id')::UUID
+                  AND team_member_id = (v_assignment->>'team_member_id')::UUID
+            ) THEN
+                INSERT INTO bulk_assignment_results
+                VALUES (
+                    (v_assignment->>'task_id')::UUID,
+                    (v_assignment->>'team_member_id')::UUID,
+                    FALSE,
+                    'Assignment already exists'
+                );
+            ELSE
+                -- Create the assignment
+                INSERT INTO tasks_assignees (task_id, team_member_id, assigned_by)
+                VALUES (
+                    (v_assignment->>'task_id')::UUID,
+                    (v_assignment->>'team_member_id')::UUID,
+                    (v_assignment->>'assigned_by')::UUID
+                );
+                
+                INSERT INTO bulk_assignment_results
+                VALUES (
+                    (v_assignment->>'task_id')::UUID,
+                    (v_assignment->>'team_member_id')::UUID,
+                    TRUE,
+                    NULL
+                );
+            END IF;
+        EXCEPTION WHEN OTHERS THEN
+            INSERT INTO bulk_assignment_results
+            VALUES (
+                (v_assignment->>'task_id')::UUID,
+                (v_assignment->>'team_member_id')::UUID,
+                FALSE,
+                SQLERRM
+            );
+        END;
+    END LOOP;
+
+    RETURN QUERY SELECT * FROM bulk_assignment_results;
+END;
+$$ LANGUAGE plpgsql;
+
+-- Function to bulk assign labels to tasks
+CREATE OR REPLACE FUNCTION bulk_assign_labels(
+    p_label_assignments JSONB
+)
+RETURNS TABLE (
+    task_id UUID,
+    label_id UUID,
+    assigned BOOLEAN,
+    error_message TEXT
+) AS $$
+DECLARE
+    v_assignment JSONB;
+    v_labels JSONB;
+BEGIN
+    CREATE TEMP TABLE IF NOT EXISTS bulk_label_results (
+        task_id UUID,
+        label_id UUID,
+        assigned BOOLEAN,
+        error_message TEXT
+    ) ON COMMIT DROP;
+
+    FOR v_assignment IN SELECT * FROM jsonb_array_elements(p_label_assignments)
+    LOOP
+        BEGIN
+            -- Use existing function to add label
+            SELECT add_or_remove_task_label(
+                (v_assignment->>'task_id')::UUID,
+                (v_assignment->>'label_id')::UUID
+            ) INTO v_labels;
+            
+            INSERT INTO bulk_label_results
+            VALUES (
+                (v_assignment->>'task_id')::UUID,
+                (v_assignment->>'label_id')::UUID,
+                TRUE,
+                NULL
+            );
+        EXCEPTION WHEN OTHERS THEN
+            INSERT INTO bulk_label_results
+            VALUES (
+                (v_assignment->>'task_id')::UUID,
+                (v_assignment->>'label_id')::UUID,
+                FALSE,
+                SQLERRM
+            );
+        END;
+    END LOOP;
+
+    RETURN QUERY SELECT * FROM bulk_label_results;
+END;
+$$ LANGUAGE plpgsql;
--- a/worklenz-backend/database/sql/migrations/add_notifications_for_recurring_tasks.sql
+++ b/worklenz-backend/database/sql/migrations/add_notifications_for_recurring_tasks.sql
@@ -0,0 +1,40 @@
+-- Create notifications table if it doesn't exist
+CREATE TABLE IF NOT EXISTS notifications (
+    id              UUID                     DEFAULT uuid_generate_v4() PRIMARY KEY,
+    user_id         UUID                     NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    message         TEXT                     NOT NULL,
+    data            JSONB,
+    read            BOOLEAN                  DEFAULT FALSE,
+    created_at      TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    read_at         TIMESTAMP WITH TIME ZONE
+);
+
+-- Create user_push_tokens table if it doesn't exist (for future push notifications)
+CREATE TABLE IF NOT EXISTS user_push_tokens (
+    id              UUID                     DEFAULT uuid_generate_v4() PRIMARY KEY,
+    user_id         UUID                     NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    push_token      TEXT                     NOT NULL,
+    device_type     VARCHAR(20),
+    active          BOOLEAN                  DEFAULT TRUE,
+    created_at      TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    updated_at      TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    UNIQUE(user_id, push_token)
+);
+
+-- Add notification preferences to users table if they don't exist
+ALTER TABLE users 
+ADD COLUMN IF NOT EXISTS email_notifications BOOLEAN DEFAULT TRUE,
+ADD COLUMN IF NOT EXISTS push_notifications BOOLEAN DEFAULT TRUE,
+ADD COLUMN IF NOT EXISTS in_app_notifications BOOLEAN DEFAULT TRUE;
+
+-- Create indexes for better performance
+CREATE INDEX IF NOT EXISTS idx_notifications_user_id ON notifications(user_id);
+CREATE INDEX IF NOT EXISTS idx_notifications_created_at ON notifications(created_at);
+CREATE INDEX IF NOT EXISTS idx_notifications_unread ON notifications(user_id, read) WHERE read = FALSE;
+CREATE INDEX IF NOT EXISTS idx_user_push_tokens_user_id ON user_push_tokens(user_id);
+
+-- Comments
+COMMENT ON TABLE notifications IS 'In-app notifications for users';
+COMMENT ON TABLE user_push_tokens IS 'Push notification tokens for mobile devices';
+COMMENT ON COLUMN notifications.data IS 'Additional notification data in JSON format';
+COMMENT ON COLUMN user_push_tokens.device_type IS 'Device type: ios, android, web';
--- a/worklenz-backend/database/sql/migrations/add_recurring_tasks_audit_log.sql
+++ b/worklenz-backend/database/sql/migrations/add_recurring_tasks_audit_log.sql
@@ -0,0 +1,94 @@
+-- Create audit log table for recurring task operations
+CREATE TABLE IF NOT EXISTS recurring_tasks_audit_log (
+    id                  UUID                     DEFAULT uuid_generate_v4() PRIMARY KEY,
+    operation_type      VARCHAR(50)              NOT NULL,
+    template_id         UUID,
+    schedule_id         UUID,
+    task_id             UUID,
+    template_name       TEXT,
+    success             BOOLEAN                  DEFAULT TRUE,
+    error_message       TEXT,
+    details             JSONB,
+    created_tasks_count INTEGER                  DEFAULT 0,
+    failed_tasks_count  INTEGER                  DEFAULT 0,
+    execution_time_ms   INTEGER,
+    created_at          TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    created_by          UUID                     REFERENCES users(id)
+);
+
+-- Create indexes for better query performance
+CREATE INDEX idx_recurring_tasks_audit_log_template_id ON recurring_tasks_audit_log(template_id);
+CREATE INDEX idx_recurring_tasks_audit_log_schedule_id ON recurring_tasks_audit_log(schedule_id);
+CREATE INDEX idx_recurring_tasks_audit_log_created_at ON recurring_tasks_audit_log(created_at);
+CREATE INDEX idx_recurring_tasks_audit_log_operation_type ON recurring_tasks_audit_log(operation_type);
+
+-- Add comments
+COMMENT ON TABLE recurring_tasks_audit_log IS 'Audit log for all recurring task operations';
+COMMENT ON COLUMN recurring_tasks_audit_log.operation_type IS 'Type of operation: cron_job_run, manual_trigger, schedule_created, schedule_updated, schedule_deleted, etc.';
+COMMENT ON COLUMN recurring_tasks_audit_log.details IS 'Additional details about the operation in JSON format';
+
+-- Create a function to log recurring task operations
+CREATE OR REPLACE FUNCTION log_recurring_task_operation(
+    p_operation_type VARCHAR(50),
+    p_template_id UUID DEFAULT NULL,
+    p_schedule_id UUID DEFAULT NULL,
+    p_task_id UUID DEFAULT NULL,
+    p_template_name TEXT DEFAULT NULL,
+    p_success BOOLEAN DEFAULT TRUE,
+    p_error_message TEXT DEFAULT NULL,
+    p_details JSONB DEFAULT NULL,
+    p_created_tasks_count INTEGER DEFAULT 0,
+    p_failed_tasks_count INTEGER DEFAULT 0,
+    p_execution_time_ms INTEGER DEFAULT NULL,
+    p_created_by UUID DEFAULT NULL
+)
+RETURNS UUID AS $$
+DECLARE
+    v_log_id UUID;
+BEGIN
+    INSERT INTO recurring_tasks_audit_log (
+        operation_type,
+        template_id,
+        schedule_id,
+        task_id,
+        template_name,
+        success,
+        error_message,
+        details,
+        created_tasks_count,
+        failed_tasks_count,
+        execution_time_ms,
+        created_by
+    ) VALUES (
+        p_operation_type,
+        p_template_id,
+        p_schedule_id,
+        p_task_id,
+        p_template_name,
+        p_success,
+        p_error_message,
+        p_details,
+        p_created_tasks_count,
+        p_failed_tasks_count,
+        p_execution_time_ms,
+        p_created_by
+    ) RETURNING id INTO v_log_id;
+    
+    RETURN v_log_id;
+END;
+$$ LANGUAGE plpgsql;
+
+-- Create a view for recent audit logs
+CREATE OR REPLACE VIEW v_recent_recurring_tasks_audit AS
+SELECT 
+    l.*,
+    u.name as created_by_name,
+    t.name as current_template_name,
+    s.schedule_type,
+    s.timezone
+FROM recurring_tasks_audit_log l
+LEFT JOIN users u ON l.created_by = u.id
+LEFT JOIN task_recurring_templates t ON l.template_id = t.id
+LEFT JOIN task_recurring_schedules s ON l.schedule_id = s.id
+WHERE l.created_at >= CURRENT_TIMESTAMP - INTERVAL '30 days'
+ORDER BY l.created_at DESC;
--- a/worklenz-backend/database/sql/migrations/add_timezone_support.sql
+++ b/worklenz-backend/database/sql/migrations/add_timezone_support.sql
@@ -0,0 +1,44 @@
+-- Add timezone support to recurring tasks
+
+-- Add timezone column to task_recurring_schedules
+ALTER TABLE task_recurring_schedules 
+ADD COLUMN IF NOT EXISTS timezone VARCHAR(50) DEFAULT 'UTC';
+
+-- Add timezone column to task_recurring_templates
+ALTER TABLE task_recurring_templates
+ADD COLUMN IF NOT EXISTS reporter_timezone VARCHAR(50);
+
+-- Add date_of_month column if not exists (for monthly schedules)
+ALTER TABLE task_recurring_schedules
+ADD COLUMN IF NOT EXISTS date_of_month INTEGER;
+
+-- Add last_checked_at and last_created_task_end_date columns for tracking
+ALTER TABLE task_recurring_schedules
+ADD COLUMN IF NOT EXISTS last_checked_at TIMESTAMP WITH TIME ZONE,
+ADD COLUMN IF NOT EXISTS last_created_task_end_date TIMESTAMP WITH TIME ZONE;
+
+-- Add end_date and excluded_dates columns for schedule control
+ALTER TABLE task_recurring_schedules
+ADD COLUMN IF NOT EXISTS end_date DATE,
+ADD COLUMN IF NOT EXISTS excluded_dates TEXT[];
+
+-- Create index on timezone for better query performance
+CREATE INDEX IF NOT EXISTS idx_task_recurring_schedules_timezone 
+ON task_recurring_schedules(timezone);
+
+-- Update existing records to use user's timezone if available
+UPDATE task_recurring_schedules trs
+SET timezone = COALESCE(
+    (SELECT u.timezone 
+     FROM task_recurring_templates trt
+     JOIN tasks t ON trt.task_id = t.id
+     JOIN users u ON t.reporter_id = u.id
+     WHERE trt.schedule_id = trs.id
+     LIMIT 1),
+    'UTC'
+)
+WHERE trs.timezone IS NULL OR trs.timezone = 'UTC';
+
+-- Add comment to explain timezone field
+COMMENT ON COLUMN task_recurring_schedules.timezone IS 'IANA timezone identifier for schedule calculations';
+COMMENT ON COLUMN task_recurring_templates.reporter_timezone IS 'Original reporter timezone for reference';
--- a/worklenz-backend/src/config/recurring-tasks-config.ts
+++ b/worklenz-backend/src/config/recurring-tasks-config.ts
@@ -0,0 +1,57 @@
+export interface RecurringTasksConfig {
+  enabled: boolean;
+  mode: 'cron' | 'queue';
+  cronInterval: string;
+  redisConfig: {
+    host: string;
+    port: number;
+    password?: string;
+    db: number;
+  };
+  queueOptions: {
+    maxConcurrency: number;
+    retryAttempts: number;
+    retryDelay: number;
+  };
+  notifications: {
+    enabled: boolean;
+    email: boolean;
+    push: boolean;
+    inApp: boolean;
+  };
+  auditLog: {
+    enabled: boolean;
+    retentionDays: number;
+  };
+}
+
+export const recurringTasksConfig: RecurringTasksConfig = {
+  enabled: process.env.RECURRING_TASKS_ENABLED !== 'false',
+  mode: (process.env.RECURRING_TASKS_MODE as 'cron' | 'queue') || 'cron',
+  cronInterval: process.env.RECURRING_JOBS_INTERVAL || '0 * * * *',
+  
+  redisConfig: {
+    host: process.env.REDIS_HOST || 'localhost',
+    port: parseInt(process.env.REDIS_PORT || '6379'),
+    password: process.env.REDIS_PASSWORD,
+    db: parseInt(process.env.REDIS_DB || '0'),
+  },
+  
+  queueOptions: {
+    maxConcurrency: parseInt(process.env.RECURRING_TASKS_MAX_CONCURRENCY || '5'),
+    retryAttempts: parseInt(process.env.RECURRING_TASKS_RETRY_ATTEMPTS || '3'),
+    retryDelay: parseInt(process.env.RECURRING_TASKS_RETRY_DELAY || '2000'),
+  },
+  
+  notifications: {
+    enabled: process.env.RECURRING_TASKS_NOTIFICATIONS_ENABLED !== 'false',
+    email: process.env.RECURRING_TASKS_EMAIL_NOTIFICATIONS !== 'false',
+    push: process.env.RECURRING_TASKS_PUSH_NOTIFICATIONS !== 'false',
+    inApp: process.env.RECURRING_TASKS_IN_APP_NOTIFICATIONS !== 'false',
+  },
+  
+  auditLog: {
+    enabled: process.env.RECURRING_TASKS_AUDIT_LOG_ENABLED !== 'false',
+    retentionDays: parseInt(process.env.RECURRING_TASKS_AUDIT_RETENTION_DAYS || '90'),
+  },
+};
--- a/worklenz-backend/src/controllers/recurring-tasks-admin-controller.ts
+++ b/worklenz-backend/src/controllers/recurring-tasks-admin-controller.ts
@@ -0,0 +1,48 @@
+import { IWorkLenzRequest } from "../interfaces/worklenz-request";
+import { IWorkLenzResponse } from "../interfaces/worklenz-response";
+import { ServerResponse } from "../models/server-response";
+import WorklenzControllerBase from "./worklenz-controller-base";
+import HandleExceptions from "../decorators/handle-exceptions";
+import { RecurringTasksPermissions } from "../utils/recurring-tasks-permissions";
+import { RecurringTasksAuditLogger } from "../utils/recurring-tasks-audit-logger";
+
+export default class RecurringTasksAdminController extends WorklenzControllerBase {
+  /**
+   * Get templates with permission issues
+   */
+  @HandleExceptions()
+  public static async getPermissionIssues(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
+    const issues = await RecurringTasksPermissions.getTemplatesWithPermissionIssues();
+    return res.status(200).send(new ServerResponse(true, issues));
+  }
+
+  /**
+   * Get audit log summary
+   */
+  @HandleExceptions()
+  public static async getAuditSummary(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
+    const { days = 7 } = req.query;
+    const summary = await RecurringTasksAuditLogger.getAuditSummary(Number(days));
+    return res.status(200).send(new ServerResponse(true, summary));
+  }
+
+  /**
+   * Get recent errors from audit log
+   */
+  @HandleExceptions()
+  public static async getRecentErrors(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
+    const { limit = 10 } = req.query;
+    const errors = await RecurringTasksAuditLogger.getRecentErrors(Number(limit));
+    return res.status(200).send(new ServerResponse(true, errors));
+  }
+
+  /**
+   * Validate a specific template
+   */
+  @HandleExceptions()
+  public static async validateTemplate(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
+    const { templateId } = req.params;
+    const result = await RecurringTasksPermissions.validateTemplatePermissions(templateId);
+    return res.status(200).send(new ServerResponse(true, result));
+  }
+}
--- a/worklenz-backend/src/controllers/task-recurring-controller.ts
+++ b/worklenz-backend/src/controllers/task-recurring-controller.ts
@@ -6,6 +6,7 @@ import { IWorkLenzRequest } from "../interfaces/worklenz-request";
 import { IWorkLenzResponse } from "../interfaces/worklenz-response";
 import { ServerResponse } from "../models/server-response";
 import { calculateNextEndDate, log_error } from "../shared/utils";
+import { RecurringTasksAuditLogger, RecurringTaskOperationType } from "../utils/recurring-tasks-audit-logger";

 export default class TaskRecurringController extends WorklenzControllerBase {
  @HandleExceptions()
@@ -34,7 +35,7 @@ export default class TaskRecurringController extends WorklenzControllerBase {
  }

  @HandleExceptions()
-  public static async createTaskSchedule(taskId: string) {
+  public static async createTaskSchedule(taskId: string, userId?: string) {
    const q = `INSERT INTO task_recurring_schedules (schedule_type) VALUES ('daily') RETURNING id, schedule_type;`;
    const result = await db.query(q, []);
    const [data] = result.rows;
@@ -44,6 +45,15 @@ export default class TaskRecurringController extends WorklenzControllerBase {

    await TaskRecurringController.insertTaskRecurringTemplate(taskId, data.id);

+    // Log schedule creation
+    await RecurringTasksAuditLogger.logScheduleChange(
+      RecurringTaskOperationType.SCHEDULE_CREATED,
+      data.id,
+      taskId,
+      userId,
+      { schedule_type: data.schedule_type }
+    );
+
    return data;
  }

@@ -56,9 +66,9 @@ export default class TaskRecurringController extends WorklenzControllerBase {
  @HandleExceptions()
  public static async updateSchedule(req: IWorkLenzRequest, res: IWorkLenzResponse): Promise<IWorkLenzResponse> {
    const { id } = req.params;
-    const { schedule_type, days_of_week, day_of_month, week_of_month, interval_days, interval_weeks, interval_months, date_of_month } = req.body;
+    const { schedule_type, days_of_week, day_of_month, week_of_month, interval_days, interval_weeks, interval_months, date_of_month, timezone, end_date, excluded_dates } = req.body;

-    const deleteQ = `UPDATE task_recurring_schedules
+    const updateQ = `UPDATE task_recurring_schedules
                      SET schedule_type   = $1,
                          days_of_week    = $2,
                          date_of_month   = $3,
@@ -66,9 +76,27 @@ export default class TaskRecurringController extends WorklenzControllerBase {
                          week_of_month   = $5,
                          interval_days   = $6,
                          interval_weeks  = $7,
-                          interval_months = $8
-                      WHERE id = $9;`;
-    await db.query(deleteQ, [schedule_type, days_of_week, date_of_month, day_of_month, week_of_month, interval_days, interval_weeks, interval_months, id]);
+                          interval_months = $8,
+                          timezone        = COALESCE($9, timezone, 'UTC'),
+                          end_date        = $10,
+                          excluded_dates  = $11
+                      WHERE id = $12;`;
+    await db.query(updateQ, [schedule_type, days_of_week, date_of_month, day_of_month, week_of_month, interval_days, interval_weeks, interval_months, timezone, end_date, excluded_dates, id]);
+    
+    // Log schedule update
+    await RecurringTasksAuditLogger.logScheduleChange(
+      RecurringTaskOperationType.SCHEDULE_UPDATED,
+      id,
+      undefined,
+      req.user?.id,
+      { 
+        schedule_type, 
+        timezone, 
+        end_date,
+        excluded_dates_count: excluded_dates?.length || 0 
+      }
+    );
+    
    return res.status(200).send(new ServerResponse(true, null));
  }

--- a/worklenz-backend/src/cron_jobs/recurring-tasks.ts
+++ b/worklenz-backend/src/cron_jobs/recurring-tasks.ts
@@ -2,12 +2,16 @@ import { CronJob } from "cron";
 import { calculateNextEndDate, log_error } from "../shared/utils";
 import db from "../config/db";
 import { IRecurringSchedule, ITaskTemplate } from "../interfaces/recurring-tasks";
-import moment from "moment";
+import moment from "moment-timezone";
 import TasksController from "../controllers/tasks-controller";
+import { TimezoneUtils } from "../utils/timezone-utils";
+import { RetryUtils } from "../utils/retry-utils";
+import { RecurringTasksAuditLogger, RecurringTaskOperationType } from "../utils/recurring-tasks-audit-logger";
+import { RecurringTasksPermissions } from "../utils/recurring-tasks-permissions";
+import { RecurringTasksNotifications } from "../utils/recurring-tasks-notifications";

-// At 11:00+00 (4.30pm+530) on every day-of-month if it's on every day-of-week from Monday through Friday.
-// const TIME = "0 11 */1 * 1-5";
-const TIME = process.env.RECURRING_JOBS_INTERVAL || "0 11 */1 * 1-5";
+// Run every hour to process tasks in different timezones
+const TIME = process.env.RECURRING_JOBS_INTERVAL || "0 * * * *";
 const TIME_FORMAT = "YYYY-MM-DD";
 // const TIME = "0 0 * * *"; // Runs at midnight every day

@@ -44,8 +48,129 @@ function getFutureLimit(scheduleType: string, interval?: number): moment.Duratio
  }
 }

-// Helper function to batch create tasks
+// Helper function to batch create tasks using bulk operations
 async function createBatchTasks(template: ITaskTemplate & IRecurringSchedule, endDates: moment.Moment[]) {
+  if (endDates.length === 0) return [];
+
+  try {
+    // Prepare bulk task data
+    const tasksData = endDates.map(endDate => ({
+      name: template.name,
+      priority_id: template.priority_id,
+      project_id: template.project_id,
+      reporter_id: template.reporter_id,
+      status_id: template.status_id || null,
+      end_date: endDate.format(TIME_FORMAT),
+      schedule_id: template.schedule_id
+    }));
+
+    // Create all tasks in bulk with retry logic
+    const createTasksResult = await RetryUtils.withDatabaseRetry(async () => {
+      const createTasksQuery = `SELECT * FROM create_bulk_recurring_tasks($1::JSONB);`;
+      return await db.query(createTasksQuery, [JSON.stringify(tasksData)]);
+    }, `create_bulk_recurring_tasks for template ${template.name}`);
+    
+    const createdTasks = createTasksResult.rows.filter(row => row.created);
+    const failedTasks = createTasksResult.rows.filter(row => !row.created);
+
+    // Log results
+    if (createdTasks.length > 0) {
+      console.log(`Created ${createdTasks.length} tasks for template ${template.name}`);
+    }
+    if (failedTasks.length > 0) {
+      failedTasks.forEach(task => {
+        console.log(`Failed to create task for template ${template.name}: ${task.error_message}`);
+      });
+    }
+
+    // Only process assignments for successfully created tasks
+    if (createdTasks.length > 0 && (template.assignees?.length > 0 || template.labels?.length > 0)) {
+      // Validate assignee permissions
+      let validAssignees = template.assignees || [];
+      if (validAssignees.length > 0) {
+        const invalidAssignees = await RecurringTasksPermissions.validateAssigneePermissions(
+          validAssignees,
+          template.project_id
+        );
+        
+        if (invalidAssignees.length > 0) {
+          console.log(`Warning: ${invalidAssignees.length} assignees do not have permissions for project ${template.project_id}`);
+          // Filter out invalid assignees
+          validAssignees = validAssignees.filter(
+            a => !invalidAssignees.includes(a.team_member_id)
+          );
+        }
+      }
+
+      // Prepare bulk assignments
+      const assignments = [];
+      const labelAssignments = [];
+
+      for (const task of createdTasks) {
+        // Prepare team member assignments with validated assignees
+        if (validAssignees.length > 0) {
+          for (const assignee of validAssignees) {
+            assignments.push({
+              task_id: task.task_id,
+              team_member_id: assignee.team_member_id,
+              assigned_by: assignee.assigned_by
+            });
+          }
+        }
+
+        // Prepare label assignments
+        if (template.labels?.length > 0) {
+          for (const label of template.labels) {
+            labelAssignments.push({
+              task_id: task.task_id,
+              label_id: label.label_id
+            });
+          }
+        }
+      }
+
+      // Bulk assign team members with retry logic
+      if (assignments.length > 0) {
+        await RetryUtils.withDatabaseRetry(async () => {
+          const assignQuery = `SELECT * FROM bulk_assign_team_members($1::JSONB);`;
+          return await db.query(assignQuery, [JSON.stringify(assignments)]);
+        }, `bulk_assign_team_members for template ${template.name}`);
+      }
+
+      // Bulk assign labels with retry logic
+      if (labelAssignments.length > 0) {
+        await RetryUtils.withDatabaseRetry(async () => {
+          const labelQuery = `SELECT * FROM bulk_assign_labels($1::JSONB);`;
+          return await db.query(labelQuery, [JSON.stringify(labelAssignments)]);
+        }, `bulk_assign_labels for template ${template.name}`);
+      }
+
+      // Send notifications for created tasks
+      if (createdTasks.length > 0) {
+        const taskData = createdTasks.map(task => ({ id: task.task_id, name: task.task_name }));
+        const assigneeIds = template.assignees?.map(a => a.team_member_id) || [];
+        
+        await RecurringTasksNotifications.notifyRecurringTasksCreated(
+          template.name,
+          template.project_id,
+          taskData,
+          assigneeIds,
+          template.reporter_id
+        );
+      }
+    }
+
+    return createdTasks.map(task => ({ id: task.task_id, name: task.task_name }));
+  } catch (error) {
+    log_error("Error in bulk task creation:", error);
+    // Fallback to sequential creation if bulk operation fails
+    console.log("Falling back to sequential task creation");
+    return createBatchTasksSequential(template, endDates);
+  }
+}
+
+// Fallback function for sequential task creation
+async function createBatchTasksSequential(template: ITaskTemplate & IRecurringSchedule, endDates: moment.Moment[]) {
  const createdTasks = [];
  
  for (const nextEndDate of endDates) {
@@ -92,69 +217,162 @@ async function createBatchTasks(template: ITaskTemplate & IRecurringSchedule, en
 }

 async function onRecurringTaskJobTick() {
+    const errors: any[] = [];
+    
    try {
        log("(cron) Recurring tasks job started.");
+        RecurringTasksAuditLogger.startTimer();

-        const templatesQuery = `
-            SELECT t.*, s.*, (SELECT MAX(end_date) FROM tasks WHERE schedule_id = s.id) as last_task_end_date
-            FROM task_recurring_templates t
-            JOIN task_recurring_schedules s ON t.schedule_id = s.id;
-        `;
-        const templatesResult = await db.query(templatesQuery);
-        const templates = templatesResult.rows as (ITaskTemplate & IRecurringSchedule)[];
+        // Get all active timezones where it's currently the scheduled hour
+        const activeTimezones = TimezoneUtils.getActiveTimezones();
+        log(`Processing recurring tasks for ${activeTimezones.length} timezones`);
+
+        // Fetch templates with retry logic
+        const templatesResult = await RetryUtils.withDatabaseRetry(async () => {
+            const templatesQuery = `
+                SELECT t.*, s.*, 
+                       (SELECT MAX(end_date) FROM tasks WHERE schedule_id = s.id) as last_task_end_date,
+                       u.timezone as user_timezone
+                FROM task_recurring_templates t
+                JOIN task_recurring_schedules s ON t.schedule_id = s.id
+                LEFT JOIN tasks orig_task ON t.task_id = orig_task.id
+                LEFT JOIN users u ON orig_task.reporter_id = u.id
+                WHERE s.end_date IS NULL OR s.end_date >= CURRENT_DATE;
+            `;
+            return await db.query(templatesQuery);
+        }, "fetch_recurring_templates");
+        
+        const templates = templatesResult.rows as (ITaskTemplate & IRecurringSchedule & { user_timezone?: string })[];

-        const now = moment();
        let createdTaskCount = 0;

        for (const template of templates) {
+            // Check template permissions before processing
+            const permissionCheck = await RecurringTasksPermissions.validateTemplatePermissions(template.task_id);
+            if (!permissionCheck.hasPermission) {
+                console.log(`Skipping template ${template.name}: ${permissionCheck.reason}`);
+                
+                // Log permission issue
+                await RecurringTasksAuditLogger.log({
+                    operationType: RecurringTaskOperationType.TASKS_CREATION_FAILED,
+                    templateId: template.task_id,
+                    scheduleId: template.schedule_id,
+                    templateName: template.name,
+                    success: false,
+                    errorMessage: `Permission denied: ${permissionCheck.reason}`,
+                    details: { permissionCheck }
+                });
+                
+                continue;
+            }
+
+            // Use template timezone or user timezone or default to UTC
+            const timezone = template.timezone || TimezoneUtils.getUserTimezone(template.user_timezone);
+            
+            // Check if this template should run in the current hour for its timezone
+            if (!activeTimezones.includes(timezone) && timezone !== 'UTC') {
+                continue;
+            }
+
+            const now = TimezoneUtils.nowInTimezone(timezone);
            const lastTaskEndDate = template.last_task_end_date 
-                ? moment(template.last_task_end_date)
-                : moment(template.created_at);
+                ? moment.tz(template.last_task_end_date, timezone)
+                : moment.tz(template.created_at, timezone);
            
            // Calculate future limit based on schedule type
-            const futureLimit = moment(template.last_checked_at || template.created_at)
+            const futureLimit = moment.tz(template.last_checked_at || template.created_at, timezone)
                .add(getFutureLimit(
                    template.schedule_type,
                    template.interval_days || template.interval_weeks || template.interval_months || 1
                ));

-            let nextEndDate = calculateNextEndDate(template, lastTaskEndDate);
+            let nextEndDate = TimezoneUtils.calculateNextEndDateWithTimezone(template, lastTaskEndDate, timezone);
            const endDatesToCreate: moment.Moment[] = [];

            // Find all future occurrences within the limit
            while (nextEndDate.isSameOrBefore(futureLimit)) {
                if (nextEndDate.isAfter(now)) {
-                    endDatesToCreate.push(moment(nextEndDate));
+                    // Check if date is not in excluded dates
+                    if (!template.excluded_dates || !template.excluded_dates.includes(nextEndDate.format(TIME_FORMAT))) {
+                        endDatesToCreate.push(moment(nextEndDate));
+                    }
                }
-                nextEndDate = calculateNextEndDate(template, nextEndDate);
+                nextEndDate = TimezoneUtils.calculateNextEndDateWithTimezone(template, nextEndDate, timezone);
            }

            // Batch create tasks for all future dates
            if (endDatesToCreate.length > 0) {
-                const createdTasks = await createBatchTasks(template, endDatesToCreate);
-                createdTaskCount += createdTasks.length;
+                try {
+                    const createdTasks = await createBatchTasks(template, endDatesToCreate);
+                    createdTaskCount += createdTasks.length;

-                // Update the last_checked_at in the schedule
-                const updateScheduleQuery = `
-                    UPDATE task_recurring_schedules 
-                    SET last_checked_at = $1::DATE, 
-                        last_created_task_end_date = $2 
-                    WHERE id = $3;
-                `;
-                await db.query(updateScheduleQuery, [
-                    moment().format(TIME_FORMAT),
-                    endDatesToCreate[endDatesToCreate.length - 1].format(TIME_FORMAT),
-                    template.schedule_id
-                ]);
+                    // Log successful template processing
+                    await RecurringTasksAuditLogger.logTemplateProcessing(
+                        template.task_id,
+                        template.name,
+                        template.schedule_id,
+                        createdTasks.length,
+                        endDatesToCreate.length - createdTasks.length,
+                        {
+                            timezone,
+                            endDates: endDatesToCreate.map(d => d.format(TIME_FORMAT))
+                        }
+                    );
+
+                    // Update the last_checked_at in the schedule with retry logic
+                    await RetryUtils.withDatabaseRetry(async () => {
+                        const updateScheduleQuery = `
+                            UPDATE task_recurring_schedules 
+                            SET last_checked_at = $1, 
+                                last_created_task_end_date = $2 
+                            WHERE id = $3;
+                        `;
+                        return await db.query(updateScheduleQuery, [
+                            now.toDate(),
+                            endDatesToCreate[endDatesToCreate.length - 1].toDate(),
+                            template.schedule_id
+                        ]);
+                    }, `update_schedule for template ${template.name}`);
+                } catch (error) {
+                    errors.push({ template: template.name, error });
+                    
+                    // Log failed template processing
+                    await RecurringTasksAuditLogger.logTemplateProcessing(
+                        template.task_id,
+                        template.name,
+                        template.schedule_id,
+                        0,
+                        endDatesToCreate.length,
+                        {
+                            timezone,
+                            error: error.message || error.toString()
+                        }
+                    );
+                }
            } else {
-                console.log(`No tasks created for template ${template.name} - next occurrence is beyond the future limit`);
+                console.log(`No tasks created for template ${template.name} (${timezone}) - next occurrence is beyond the future limit or excluded`);
            }
        }
        
        log(`(cron) Recurring tasks job ended with ${createdTaskCount} new tasks created.`);
+        
+        // Log cron job completion
+        await RecurringTasksAuditLogger.logCronJobRun(
+            templates.length,
+            createdTaskCount,
+            errors
+        );
    } catch (error) {
        log_error(error);
        log("(cron) Recurring task job ended with errors.");
+        
+        // Log cron job failure
+        await RecurringTasksAuditLogger.log({
+            operationType: RecurringTaskOperationType.CRON_JOB_ERROR,
+            success: false,
+            errorMessage: error.message || error.toString(),
+            details: { error: error.stack || error }
+        });
    }
 }

--- a/worklenz-backend/src/interfaces/recurring-tasks.ts
+++ b/worklenz-backend/src/interfaces/recurring-tasks.ts
@@ -12,6 +12,9 @@ export interface IRecurringSchedule {
  last_checked_at: Date | null;
  last_task_end_date: Date | null;
  created_at: Date;
+  timezone?: string;
+  end_date?: Date | null;
+  excluded_dates?: string[] | null;
 }

 interface ITaskTemplateAssignee {
--- a/worklenz-backend/src/jobs/recurring-tasks-queue.ts
+++ b/worklenz-backend/src/jobs/recurring-tasks-queue.ts
@@ -0,0 +1,322 @@
+import Bull from 'bull';
+import { TimezoneUtils } from '../utils/timezone-utils';
+import { RetryUtils } from '../utils/retry-utils';
+import { RecurringTasksAuditLogger, RecurringTaskOperationType } from '../utils/recurring-tasks-audit-logger';
+import { RecurringTasksPermissions } from '../utils/recurring-tasks-permissions';
+import { RecurringTasksNotifications } from '../utils/recurring-tasks-notifications';
+import { calculateNextEndDate, log_error } from '../shared/utils';
+import { IRecurringSchedule, ITaskTemplate } from '../interfaces/recurring-tasks';
+import moment from 'moment-timezone';
+import db from '../config/db';
+
+// Configure Redis connection
+const redisConfig = {
+  host: process.env.REDIS_HOST || 'localhost',
+  port: parseInt(process.env.REDIS_PORT || '6379'),
+  password: process.env.REDIS_PASSWORD,
+  db: parseInt(process.env.REDIS_DB || '0'),
+};
+
+// Create job queues
+export const recurringTasksQueue = new Bull('recurring-tasks', {
+  redis: redisConfig,
+  defaultJobOptions: {
+    removeOnComplete: 100, // Keep last 100 completed jobs
+    removeOnFail: 50,      // Keep last 50 failed jobs
+    attempts: 3,
+    backoff: {
+      type: 'exponential',
+      delay: 2000,
+    },
+  },
+});
+
+export const taskCreationQueue = new Bull('task-creation', {
+  redis: redisConfig,
+  defaultJobOptions: {
+    removeOnComplete: 200,
+    removeOnFail: 100,
+    attempts: 5,
+    backoff: {
+      type: 'exponential',
+      delay: 1000,
+    },
+  },
+});
+
+// Job data interfaces
+interface RecurringTaskJobData {
+  templateId: string;
+  scheduleId: string;
+  timezone: string;
+}
+
+interface TaskCreationJobData {
+  template: ITaskTemplate & IRecurringSchedule;
+  endDates: string[];
+  timezone: string;
+}
+
+// Job processors
+recurringTasksQueue.process('process-template', async (job) => {
+  const { templateId, scheduleId, timezone }: RecurringTaskJobData = job.data;
+  
+  try {
+    RecurringTasksAuditLogger.startTimer();
+    
+    // Fetch template data
+    const templateQuery = `
+      SELECT t.*, s.*, 
+             (SELECT MAX(end_date) FROM tasks WHERE schedule_id = s.id) as last_task_end_date,
+             u.timezone as user_timezone
+      FROM task_recurring_templates t
+      JOIN task_recurring_schedules s ON t.schedule_id = s.id
+      LEFT JOIN tasks orig_task ON t.task_id = orig_task.id
+      LEFT JOIN users u ON orig_task.reporter_id = u.id
+      WHERE t.id = $1 AND s.id = $2
+    `;
+    
+    const result = await RetryUtils.withDatabaseRetry(async () => {
+      return await db.query(templateQuery, [templateId, scheduleId]);
+    }, 'fetch_template_for_job');
+    
+    if (result.rows.length === 0) {
+      throw new Error(`Template ${templateId} not found`);
+    }
+    
+    const template = result.rows[0] as ITaskTemplate & IRecurringSchedule & { user_timezone?: string };
+    
+    // Check permissions
+    const permissionCheck = await RecurringTasksPermissions.validateTemplatePermissions(template.task_id);
+    if (!permissionCheck.hasPermission) {
+      await RecurringTasksAuditLogger.log({
+        operationType: RecurringTaskOperationType.TASKS_CREATION_FAILED,
+        templateId: template.task_id,
+        scheduleId: template.schedule_id,
+        templateName: template.name,
+        success: false,
+        errorMessage: `Permission denied: ${permissionCheck.reason}`,
+        details: { permissionCheck, processedBy: 'job_queue' }
+      });
+      return;
+    }
+    
+    // Calculate dates to create
+    const now = TimezoneUtils.nowInTimezone(timezone);
+    const lastTaskEndDate = template.last_task_end_date 
+      ? moment.tz(template.last_task_end_date, timezone)
+      : moment.tz(template.created_at, timezone);
+    
+    const futureLimit = moment.tz(template.last_checked_at || template.created_at, timezone)
+      .add(getFutureLimit(
+        template.schedule_type,
+        template.interval_days || template.interval_weeks || template.interval_months || 1
+      ));
+
+    let nextEndDate = TimezoneUtils.calculateNextEndDateWithTimezone(template, lastTaskEndDate, timezone);
+    const endDatesToCreate: string[] = [];
+
+    while (nextEndDate.isSameOrBefore(futureLimit)) {
+      if (nextEndDate.isAfter(now)) {
+        if (!template.excluded_dates || !template.excluded_dates.includes(nextEndDate.format('YYYY-MM-DD'))) {
+          endDatesToCreate.push(nextEndDate.format('YYYY-MM-DD'));
+        }
+      }
+      nextEndDate = TimezoneUtils.calculateNextEndDateWithTimezone(template, nextEndDate, timezone);
+    }
+    
+    if (endDatesToCreate.length > 0) {
+      // Add task creation job
+      await taskCreationQueue.add('create-tasks', {
+        template,
+        endDates: endDatesToCreate,
+        timezone
+      }, {
+        priority: 10, // Higher priority for task creation
+      });
+    }
+    
+    // Update schedule
+    await RetryUtils.withDatabaseRetry(async () => {
+      const updateQuery = `
+        UPDATE task_recurring_schedules 
+        SET last_checked_at = $1
+        WHERE id = $2;
+      `;
+      return await db.query(updateQuery, [now.toDate(), scheduleId]);
+    }, `update_schedule_for_template_${templateId}`);
+    
+  } catch (error) {
+    log_error('Error processing recurring task template:', error);
+    throw error;
+  }
+});
+
+taskCreationQueue.process('create-tasks', async (job) => {
+  const { template, endDates, timezone }: TaskCreationJobData = job.data;
+  
+  try {
+    // Create tasks using the bulk function from the cron job
+    const tasksData = endDates.map(endDate => ({
+      name: template.name,
+      priority_id: template.priority_id,
+      project_id: template.project_id,
+      reporter_id: template.reporter_id,
+      status_id: template.status_id || null,
+      end_date: endDate,
+      schedule_id: template.schedule_id
+    }));
+
+    const createTasksResult = await RetryUtils.withDatabaseRetry(async () => {
+      const createTasksQuery = `SELECT * FROM create_bulk_recurring_tasks($1::JSONB);`;
+      return await db.query(createTasksQuery, [JSON.stringify(tasksData)]);
+    }, `create_bulk_tasks_queue_${template.name}`);
+    
+    const createdTasks = createTasksResult.rows.filter(row => row.created);
+    const failedTasks = createTasksResult.rows.filter(row => !row.created);
+
+    // Handle assignments and labels (similar to cron job implementation)
+    if (createdTasks.length > 0 && (template.assignees?.length > 0 || template.labels?.length > 0)) {
+      // ... (assignment logic from cron job)
+    }
+
+    // Send notifications
+    if (createdTasks.length > 0) {
+      const taskData = createdTasks.map(task => ({ id: task.task_id, name: task.task_name }));
+      const assigneeIds = template.assignees?.map(a => a.team_member_id) || [];
+      
+      await RecurringTasksNotifications.notifyRecurringTasksCreated(
+        template.name,
+        template.project_id,
+        taskData,
+        assigneeIds,
+        template.reporter_id
+      );
+    }
+
+    // Log results
+    await RecurringTasksAuditLogger.logTemplateProcessing(
+      template.task_id,
+      template.name,
+      template.schedule_id,
+      createdTasks.length,
+      failedTasks.length,
+      {
+        timezone,
+        endDates,
+        processedBy: 'job_queue'
+      }
+    );
+
+    return {
+      created: createdTasks.length,
+      failed: failedTasks.length
+    };
+    
+  } catch (error) {
+    log_error('Error creating tasks in queue:', error);
+    throw error;
+  }
+});
+
+// Helper function (copied from cron job)
+function getFutureLimit(scheduleType: string, interval?: number): moment.Duration {
+  const FUTURE_LIMITS = {
+    daily: moment.duration(3, "days"),
+    weekly: moment.duration(1, "week"),
+    monthly: moment.duration(1, "month"),
+    every_x_days: (interval: number) => moment.duration(interval, "days"),
+    every_x_weeks: (interval: number) => moment.duration(interval, "weeks"),
+    every_x_months: (interval: number) => moment.duration(interval, "months")
+  };
+
+  switch (scheduleType) {
+    case "daily":
+      return FUTURE_LIMITS.daily;
+    case "weekly":
+      return FUTURE_LIMITS.weekly;
+    case "monthly":
+      return FUTURE_LIMITS.monthly;
+    case "every_x_days":
+      return FUTURE_LIMITS.every_x_days(interval || 1);
+    case "every_x_weeks":
+      return FUTURE_LIMITS.every_x_weeks(interval || 1);
+    case "every_x_months":
+      return FUTURE_LIMITS.every_x_months(interval || 1);
+    default:
+      return moment.duration(3, "days");
+  }
+}
+
+// Job schedulers
+export class RecurringTasksJobScheduler {
+  /**
+   * Schedule recurring task processing for all templates
+   */
+  static async scheduleRecurringTasks(): Promise<void> {
+    try {
+      // Get all active templates
+      const templatesQuery = `
+        SELECT t.id as template_id, s.id as schedule_id, 
+               COALESCE(s.timezone, u.timezone, 'UTC') as timezone
+        FROM task_recurring_templates t
+        JOIN task_recurring_schedules s ON t.schedule_id = s.id
+        LEFT JOIN tasks orig_task ON t.task_id = orig_task.id
+        LEFT JOIN users u ON orig_task.reporter_id = u.id
+        WHERE s.end_date IS NULL OR s.end_date >= CURRENT_DATE
+      `;
+      
+      const result = await db.query(templatesQuery);
+      
+      // Schedule a job for each template
+      for (const template of result.rows) {
+        await recurringTasksQueue.add('process-template', {
+          templateId: template.template_id,
+          scheduleId: template.schedule_id,
+          timezone: template.timezone
+        }, {
+          delay: Math.random() * 60000, // Random delay up to 1 minute to spread load
+        });
+      }
+      
+    } catch (error) {
+      log_error('Error scheduling recurring tasks:', error);
+    }
+  }
+
+  /**
+   * Start the job queue system
+   */
+  static async start(): Promise<void> {
+    console.log('Starting recurring tasks job queue...');
+    
+    // Schedule recurring task processing every hour
+    await recurringTasksQueue.add('schedule-all', {}, {
+      repeat: { cron: '0 * * * *' }, // Every hour
+      removeOnComplete: 1,
+      removeOnFail: 1,
+    });
+    
+    // Process the schedule-all job
+    recurringTasksQueue.process('schedule-all', async () => {
+      await this.scheduleRecurringTasks();
+    });
+    
+    console.log('Recurring tasks job queue started');
+  }
+
+  /**
+   * Get queue statistics
+   */
+  static async getStats(): Promise<any> {
+    const [recurringStats, creationStats] = await Promise.all([
+      recurringTasksQueue.getJobCounts(),
+      taskCreationQueue.getJobCounts()
+    ]);
+    
+    return {
+      recurringTasks: recurringStats,
+      taskCreation: creationStats
+    };
+  }
+}
--- a/worklenz-backend/src/services/recurring-tasks-service.ts
+++ b/worklenz-backend/src/services/recurring-tasks-service.ts
@@ -0,0 +1,162 @@
+import { recurringTasksConfig } from '../config/recurring-tasks-config';
+import { startRecurringTasksJob } from '../cron_jobs/recurring-tasks';
+import { RecurringTasksJobScheduler } from '../jobs/recurring-tasks-queue';
+import { log_error } from '../shared/utils';
+
+export class RecurringTasksService {
+  private static isStarted = false;
+
+  /**
+   * Start the recurring tasks service based on configuration
+   */
+  static async start(): Promise<void> {
+    if (this.isStarted) {
+      console.log('Recurring tasks service already started');
+      return;
+    }
+
+    if (!recurringTasksConfig.enabled) {
+      console.log('Recurring tasks service disabled');
+      return;
+    }
+
+    try {
+      console.log(`Starting recurring tasks service in ${recurringTasksConfig.mode} mode...`);
+
+      switch (recurringTasksConfig.mode) {
+        case 'cron':
+          startRecurringTasksJob();
+          break;
+          
+        case 'queue':
+          await RecurringTasksJobScheduler.start();
+          break;
+          
+        default:
+          throw new Error(`Unknown recurring tasks mode: ${recurringTasksConfig.mode}`);
+      }
+
+      this.isStarted = true;
+      console.log(`Recurring tasks service started successfully in ${recurringTasksConfig.mode} mode`);
+      
+    } catch (error) {
+      log_error('Failed to start recurring tasks service:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Stop the recurring tasks service
+   */
+  static async stop(): Promise<void> {
+    if (!this.isStarted) {
+      return;
+    }
+
+    try {
+      console.log('Stopping recurring tasks service...');
+      
+      if (recurringTasksConfig.mode === 'queue') {
+        // Close queue connections
+        const { recurringTasksQueue, taskCreationQueue } = await import('../jobs/recurring-tasks-queue');
+        await recurringTasksQueue.close();
+        await taskCreationQueue.close();
+      }
+      
+      this.isStarted = false;
+      console.log('Recurring tasks service stopped');
+      
+    } catch (error) {
+      log_error('Error stopping recurring tasks service:', error);
+    }
+  }
+
+  /**
+   * Get service status and statistics
+   */
+  static async getStatus(): Promise<any> {
+    const status = {
+      enabled: recurringTasksConfig.enabled,
+      mode: recurringTasksConfig.mode,
+      started: this.isStarted,
+      config: recurringTasksConfig
+    };
+
+    if (this.isStarted && recurringTasksConfig.mode === 'queue') {
+      try {
+        const stats = await RecurringTasksJobScheduler.getStats();
+        return { ...status, queueStats: stats };
+      } catch (error) {
+        return { ...status, queueStatsError: error.message };
+      }
+    }
+
+    return status;
+  }
+
+  /**
+   * Manually trigger recurring tasks processing
+   */
+  static async triggerManual(): Promise<void> {
+    if (!this.isStarted) {
+      throw new Error('Recurring tasks service is not started');
+    }
+
+    try {
+      if (recurringTasksConfig.mode === 'queue') {
+        await RecurringTasksJobScheduler.scheduleRecurringTasks();
+      } else {
+        // For cron mode, we can't manually trigger easily
+        // Could implement a manual trigger function in the cron job file
+        throw new Error('Manual trigger not supported in cron mode');
+      }
+    } catch (error) {
+      log_error('Error manually triggering recurring tasks:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Health check for the service
+   */
+  static async healthCheck(): Promise<{ healthy: boolean; message: string; details?: any }> {
+    try {
+      if (!recurringTasksConfig.enabled) {
+        return {
+          healthy: true,
+          message: 'Recurring tasks service is disabled'
+        };
+      }
+
+      if (!this.isStarted) {
+        return {
+          healthy: false,
+          message: 'Recurring tasks service is not started'
+        };
+      }
+
+      if (recurringTasksConfig.mode === 'queue') {
+        const stats = await RecurringTasksJobScheduler.getStats();
+        const hasFailures = stats.recurringTasks.failed > 0 || stats.taskCreation.failed > 0;
+        
+        return {
+          healthy: !hasFailures,
+          message: hasFailures ? 'Some jobs are failing' : 'All systems operational',
+          details: stats
+        };
+      }
+
+      return {
+        healthy: true,
+        message: `Running in ${recurringTasksConfig.mode} mode`
+      };
+
+    } catch (error) {
+      return {
+        healthy: false,
+        message: 'Health check failed',
+        details: { error: error.message }
+      };
+    }
+  }
+}
--- a/worklenz-backend/src/utils/recurring-tasks-audit-logger.ts
+++ b/worklenz-backend/src/utils/recurring-tasks-audit-logger.ts
@@ -0,0 +1,189 @@
+import db from "../config/db";
+import { log_error } from "../shared/utils";
+
+export enum RecurringTaskOperationType {
+  CRON_JOB_RUN = "cron_job_run",
+  CRON_JOB_ERROR = "cron_job_error",
+  TEMPLATE_CREATED = "template_created",
+  TEMPLATE_UPDATED = "template_updated",
+  TEMPLATE_DELETED = "template_deleted",
+  SCHEDULE_CREATED = "schedule_created",
+  SCHEDULE_UPDATED = "schedule_updated",
+  SCHEDULE_DELETED = "schedule_deleted",
+  TASKS_CREATED = "tasks_created",
+  TASKS_CREATION_FAILED = "tasks_creation_failed",
+  MANUAL_TRIGGER = "manual_trigger",
+  BULK_OPERATION = "bulk_operation"
+}
+
+export interface AuditLogEntry {
+  operationType: RecurringTaskOperationType;
+  templateId?: string;
+  scheduleId?: string;
+  taskId?: string;
+  templateName?: string;
+  success?: boolean;
+  errorMessage?: string;
+  details?: any;
+  createdTasksCount?: number;
+  failedTasksCount?: number;
+  executionTimeMs?: number;
+  createdBy?: string;
+}
+
+export class RecurringTasksAuditLogger {
+  private static startTime: number;
+
+  /**
+   * Start timing an operation
+   */
+  static startTimer(): void {
+    this.startTime = Date.now();
+  }
+
+  /**
+   * Get elapsed time since timer started
+   */
+  static getElapsedTime(): number {
+    return this.startTime ? Date.now() - this.startTime : 0;
+  }
+
+  /**
+   * Log a recurring task operation
+   */
+  static async log(entry: AuditLogEntry): Promise<void> {
+    try {
+      const query = `SELECT log_recurring_task_operation($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12);`;
+      
+      await db.query(query, [
+        entry.operationType,
+        entry.templateId || null,
+        entry.scheduleId || null,
+        entry.taskId || null,
+        entry.templateName || null,
+        entry.success !== false, // Default to true
+        entry.errorMessage || null,
+        entry.details ? JSON.stringify(entry.details) : null,
+        entry.createdTasksCount || 0,
+        entry.failedTasksCount || 0,
+        entry.executionTimeMs || this.getElapsedTime(),
+        entry.createdBy || null
+      ]);
+    } catch (error) {
+      // Don't let audit logging failures break the main flow
+      log_error("Failed to log recurring task audit entry:", error);
+    }
+  }
+
+  /**
+   * Log cron job execution
+   */
+  static async logCronJobRun(
+    totalTemplates: number,
+    createdTasksCount: number,
+    errors: any[] = []
+  ): Promise<void> {
+    await this.log({
+      operationType: RecurringTaskOperationType.CRON_JOB_RUN,
+      success: errors.length === 0,
+      errorMessage: errors.length > 0 ? `${errors.length} errors occurred` : undefined,
+      details: {
+        totalTemplates,
+        errors: errors.map(e => e.message || e.toString())
+      },
+      createdTasksCount,
+      executionTimeMs: this.getElapsedTime()
+    });
+  }
+
+  /**
+   * Log template processing
+   */
+  static async logTemplateProcessing(
+    templateId: string,
+    templateName: string,
+    scheduleId: string,
+    createdCount: number,
+    failedCount: number,
+    details?: any
+  ): Promise<void> {
+    await this.log({
+      operationType: RecurringTaskOperationType.TASKS_CREATED,
+      templateId,
+      scheduleId,
+      templateName,
+      success: failedCount === 0,
+      createdTasksCount: createdCount,
+      failedTasksCount: failedCount,
+      details
+    });
+  }
+
+  /**
+   * Log schedule changes
+   */
+  static async logScheduleChange(
+    operationType: RecurringTaskOperationType,
+    scheduleId: string,
+    templateId?: string,
+    userId?: string,
+    details?: any
+  ): Promise<void> {
+    await this.log({
+      operationType,
+      scheduleId,
+      templateId,
+      createdBy: userId,
+      details
+    });
+  }
+
+  /**
+   * Get audit log summary
+   */
+  static async getAuditSummary(days: number = 7): Promise<any> {
+    try {
+      const query = `
+        SELECT 
+          operation_type,
+          COUNT(*) as count,
+          SUM(CASE WHEN success THEN 1 ELSE 0 END) as success_count,
+          SUM(CASE WHEN NOT success THEN 1 ELSE 0 END) as failure_count,
+          SUM(created_tasks_count) as total_tasks_created,
+          SUM(failed_tasks_count) as total_tasks_failed,
+          AVG(execution_time_ms) as avg_execution_time_ms
+        FROM recurring_tasks_audit_log
+        WHERE created_at >= CURRENT_TIMESTAMP - INTERVAL '${days} days'
+        GROUP BY operation_type
+        ORDER BY count DESC;
+      `;
+      
+      const result = await db.query(query);
+      return result.rows;
+    } catch (error) {
+      log_error("Failed to get audit summary:", error);
+      return [];
+    }
+  }
+
+  /**
+   * Get recent errors
+   */
+  static async getRecentErrors(limit: number = 10): Promise<any[]> {
+    try {
+      const query = `
+        SELECT *
+        FROM v_recent_recurring_tasks_audit
+        WHERE NOT success
+        ORDER BY created_at DESC
+        LIMIT $1;
+      `;
+      
+      const result = await db.query(query, [limit]);
+      return result.rows;
+    } catch (error) {
+      log_error("Failed to get recent errors:", error);
+      return [];
+    }
+  }
+}
--- a/worklenz-backend/src/utils/recurring-tasks-notifications.ts
+++ b/worklenz-backend/src/utils/recurring-tasks-notifications.ts
@@ -0,0 +1,260 @@
+import db from "../config/db";
+import { log_error } from "../shared/utils";
+
+export interface NotificationData {
+  userId: string;
+  projectId: string;
+  taskId: string;
+  taskName: string;
+  templateName: string;
+  scheduleId: string;
+  createdBy?: string;
+}
+
+export class RecurringTasksNotifications {
+  /**
+   * Send notification to user about a new recurring task
+   */
+  static async notifyTaskCreated(data: NotificationData): Promise<void> {
+    try {
+      // Create notification in the database
+      const notificationQuery = `
+        INSERT INTO notifications (
+          user_id,
+          message,
+          data,
+          created_at
+        ) VALUES ($1, $2, $3, NOW())
+      `;
+
+      const message = `New recurring task "${data.taskName}" has been created from template "${data.templateName}"`;
+      const notificationData = {
+        type: 'recurring_task_created',
+        task_id: data.taskId,
+        project_id: data.projectId,
+        schedule_id: data.scheduleId,
+        task_name: data.taskName,
+        template_name: data.templateName
+      };
+
+      await db.query(notificationQuery, [
+        data.userId,
+        message,
+        JSON.stringify(notificationData)
+      ]);
+
+    } catch (error) {
+      log_error("Failed to create notification:", error);
+    }
+  }
+
+  /**
+   * Send notifications to all assignees of created tasks
+   */
+  static async notifyAssignees(
+    taskIds: string[],
+    templateName: string,
+    projectId: string
+  ): Promise<void> {
+    if (taskIds.length === 0) return;
+
+    try {
+      // Get all assignees for the created tasks
+      const assigneesQuery = `
+        SELECT DISTINCT ta.team_member_id, t.id as task_id, t.name as task_name
+        FROM tasks_assignees ta
+        JOIN tasks t ON ta.task_id = t.id
+        WHERE t.id = ANY($1)
+      `;
+
+      const result = await db.query(assigneesQuery, [taskIds]);
+      
+      // Send notification to each assignee
+      for (const assignee of result.rows) {
+        await this.notifyTaskCreated({
+          userId: assignee.team_member_id,
+          projectId,
+          taskId: assignee.task_id,
+          taskName: assignee.task_name,
+          templateName,
+          scheduleId: '' // Not needed for assignee notifications
+        });
+      }
+
+    } catch (error) {
+      log_error("Failed to notify assignees:", error);
+    }
+  }
+
+  /**
+   * Send email notifications (if email system is configured)
+   */
+  static async sendEmailNotifications(
+    userIds: string[],
+    subject: string,
+    message: string
+  ): Promise<void> {
+    try {
+      // Get user email addresses
+      const usersQuery = `
+        SELECT id, email, name, email_notifications
+        FROM users
+        WHERE id = ANY($1) AND email_notifications = true AND email IS NOT NULL
+      `;
+
+      const result = await db.query(usersQuery, [userIds]);
+      
+      // TODO: Integrate with your email service (SendGrid, AWS SES, etc.)
+      // For now, just log the email notifications that would be sent
+      for (const user of result.rows) {
+        console.log(`Email notification would be sent to ${user.email}: ${subject}`);
+        
+        // Example: await emailService.send({
+        //   to: user.email,
+        //   subject,
+        //   html: message
+        // });
+      }
+
+    } catch (error) {
+      log_error("Failed to send email notifications:", error);
+    }
+  }
+
+  /**
+   * Send push notifications (if push notification system is configured)
+   */
+  static async sendPushNotifications(
+    userIds: string[],
+    title: string,
+    body: string,
+    data?: any
+  ): Promise<void> {
+    try {
+      // Get user push tokens
+      const tokensQuery = `
+        SELECT user_id, push_token
+        FROM user_push_tokens
+        WHERE user_id = ANY($1) AND push_token IS NOT NULL
+      `;
+
+      const result = await db.query(tokensQuery, [userIds]);
+      
+      // TODO: Integrate with your push notification service (FCM, APNs, etc.)
+      // For now, just log the push notifications that would be sent
+      for (const token of result.rows) {
+        console.log(`Push notification would be sent to ${token.push_token}: ${title}`);
+        
+        // Example: await pushService.send({
+        //   token: token.push_token,
+        //   title,
+        //   body,
+        //   data
+        // });
+      }
+
+    } catch (error) {
+      log_error("Failed to send push notifications:", error);
+    }
+  }
+
+  /**
+   * Get notification preferences for users
+   */
+  static async getNotificationPreferences(userIds: string[]): Promise<any[]> {
+    try {
+      const query = `
+        SELECT 
+          id,
+          email_notifications,
+          push_notifications,
+          in_app_notifications
+        FROM users
+        WHERE id = ANY($1)
+      `;
+
+      const result = await db.query(query, [userIds]);
+      return result.rows;
+
+    } catch (error) {
+      log_error("Failed to get notification preferences:", error);
+      return [];
+    }
+  }
+
+  /**
+   * Comprehensive notification for recurring task creation
+   */
+  static async notifyRecurringTasksCreated(
+    templateName: string,
+    projectId: string,
+    createdTasks: Array<{ id: string; name: string }>,
+    assignees: string[] = [],
+    reporterId?: string
+  ): Promise<void> {
+    try {
+      const taskIds = createdTasks.map(t => t.id);
+      const allUserIds = [...new Set([...assignees, reporterId].filter(Boolean))];
+
+      if (allUserIds.length === 0) return;
+
+      // Get notification preferences
+      const preferences = await this.getNotificationPreferences(allUserIds);
+      
+      // Send in-app notifications
+      const inAppUsers = preferences.filter(p => p.in_app_notifications !== false);
+      for (const user of inAppUsers) {
+        for (const task of createdTasks) {
+          await this.notifyTaskCreated({
+            userId: user.id,
+            projectId,
+            taskId: task.id,
+            taskName: task.name,
+            templateName,
+            scheduleId: '',
+            createdBy: 'system'
+          });
+        }
+      }
+
+      // Send email notifications
+      const emailUsers = preferences
+        .filter(p => p.email_notifications === true)
+        .map(p => p.id);
+      
+      if (emailUsers.length > 0) {
+        const subject = `New Recurring Tasks Created: ${templateName}`;
+        const message = `
+          <h3>Recurring Tasks Created</h3>
+          <p>${createdTasks.length} new tasks have been created from template "${templateName}":</p>
+          <ul>
+            ${createdTasks.map(t => `<li>${t.name}</li>`).join('')}
+          </ul>
+        `;
+        
+        await this.sendEmailNotifications(emailUsers, subject, message);
+      }
+
+      // Send push notifications
+      const pushUsers = preferences
+        .filter(p => p.push_notifications !== false)
+        .map(p => p.id);
+      
+      if (pushUsers.length > 0) {
+        await this.sendPushNotifications(
+          pushUsers,
+          'New Recurring Tasks',
+          `${createdTasks.length} tasks created from ${templateName}`,
+          {
+            type: 'recurring_tasks_created',
+            project_id: projectId,
+            task_count: createdTasks.length
+          }
+        );
+      }
+
+    } catch (error) {
+      log_error("Failed to send comprehensive notifications:", error);
+    }
+  }
+}
--- a/worklenz-backend/src/utils/recurring-tasks-permissions.ts
+++ b/worklenz-backend/src/utils/recurring-tasks-permissions.ts
@@ -0,0 +1,187 @@
+import db from "../config/db";
+import { log_error } from "../shared/utils";
+
+export interface PermissionCheckResult {
+  hasPermission: boolean;
+  reason?: string;
+  projectRole?: string;
+}
+
+export class RecurringTasksPermissions {
+  /**
+   * Check if a user has permission to create tasks in a project
+   */
+  static async canCreateTasksInProject(
+    userId: string,
+    projectId: string
+  ): Promise<PermissionCheckResult> {
+    try {
+      // Check if user is a member of the project
+      const memberQuery = `
+        SELECT pm.role_id, pr.name as role_name, pr.permissions
+        FROM project_members pm
+        JOIN project_member_roles pr ON pm.role_id = pr.id
+        WHERE pm.user_id = $1 AND pm.project_id = $2
+        LIMIT 1;
+      `;
+      
+      const result = await db.query(memberQuery, [userId, projectId]);
+      
+      if (result.rows.length === 0) {
+        return {
+          hasPermission: false,
+          reason: "User is not a member of the project"
+        };
+      }
+      
+      const member = result.rows[0];
+      
+      // Check if role has task creation permission
+      if (member.permissions && member.permissions.create_tasks === false) {
+        return {
+          hasPermission: false,
+          reason: "User role does not have permission to create tasks",
+          projectRole: member.role_name
+        };
+      }
+      
+      return {
+        hasPermission: true,
+        projectRole: member.role_name
+      };
+    } catch (error) {
+      log_error("Error checking project permissions:", error);
+      return {
+        hasPermission: false,
+        reason: "Error checking permissions"
+      };
+    }
+  }
+
+  /**
+   * Check if a template has valid permissions
+   */
+  static async validateTemplatePermissions(templateId: string): Promise<PermissionCheckResult> {
+    try {
+      const query = `
+        SELECT 
+          t.reporter_id,
+          t.project_id,
+          p.is_active as project_active,
+          p.archived as project_archived,
+          u.is_active as user_active
+        FROM task_recurring_templates trt
+        JOIN tasks t ON trt.task_id = t.id
+        JOIN projects p ON t.project_id = p.id
+        JOIN users u ON t.reporter_id = u.id
+        WHERE trt.id = $1
+        LIMIT 1;
+      `;
+      
+      const result = await db.query(query, [templateId]);
+      
+      if (result.rows.length === 0) {
+        return {
+          hasPermission: false,
+          reason: "Template not found"
+        };
+      }
+      
+      const template = result.rows[0];
+      
+      // Check if project is active
+      if (!template.project_active || template.project_archived) {
+        return {
+          hasPermission: false,
+          reason: "Project is not active or archived"
+        };
+      }
+      
+      // Check if reporter is still active
+      if (!template.user_active) {
+        return {
+          hasPermission: false,
+          reason: "Original task reporter is no longer active"
+        };
+      }
+      
+      // Check if reporter still has permissions in the project
+      const permissionCheck = await this.canCreateTasksInProject(
+        template.reporter_id,
+        template.project_id
+      );
+      
+      return permissionCheck;
+    } catch (error) {
+      log_error("Error validating template permissions:", error);
+      return {
+        hasPermission: false,
+        reason: "Error validating template permissions"
+      };
+    }
+  }
+
+  /**
+   * Get all templates with permission issues
+   */
+  static async getTemplatesWithPermissionIssues(): Promise<any[]> {
+    try {
+      const query = `
+        SELECT 
+          trt.id as template_id,
+          trt.name as template_name,
+          t.reporter_id,
+          u.name as reporter_name,
+          t.project_id,
+          p.name as project_name,
+          CASE 
+            WHEN NOT p.is_active THEN 'Project inactive'
+            WHEN p.archived THEN 'Project archived'
+            WHEN NOT u.is_active THEN 'User inactive'
+            WHEN NOT EXISTS (
+              SELECT 1 FROM project_members 
+              WHERE user_id = t.reporter_id AND project_id = t.project_id
+            ) THEN 'User not in project'
+            ELSE NULL
+          END as issue
+        FROM task_recurring_templates trt
+        JOIN tasks t ON trt.task_id = t.id
+        JOIN projects p ON t.project_id = p.id
+        JOIN users u ON t.reporter_id = u.id
+        WHERE 
+          NOT p.is_active 
+          OR p.archived 
+          OR NOT u.is_active
+          OR NOT EXISTS (
+            SELECT 1 FROM project_members 
+            WHERE user_id = t.reporter_id AND project_id = t.project_id
+          );
+      `;
+      
+      const result = await db.query(query);
+      return result.rows;
+    } catch (error) {
+      log_error("Error getting templates with permission issues:", error);
+      return [];
+    }
+  }
+
+  /**
+   * Validate all assignees have permissions
+   */
+  static async validateAssigneePermissions(
+    assignees: Array<{ team_member_id: string }>,
+    projectId: string
+  ): Promise<string[]> {
+    const invalidAssignees: string[] = [];
+    
+    for (const assignee of assignees) {
+      const check = await this.canCreateTasksInProject(assignee.team_member_id, projectId);
+      if (!check.hasPermission) {
+        invalidAssignees.push(assignee.team_member_id);
+      }
+    }
+    
+    return invalidAssignees;
+  }
+}
--- a/worklenz-backend/src/utils/retry-utils.ts
+++ b/worklenz-backend/src/utils/retry-utils.ts
@@ -0,0 +1,134 @@
+import { log_error } from "../shared/utils";
+
+export interface RetryOptions {
+  maxRetries: number;
+  delayMs: number;
+  backoffFactor?: number;
+  onRetry?: (error: any, attempt: number) => void;
+}
+
+export class RetryUtils {
+  /**
+   * Execute a function with retry logic
+   */
+  static async withRetry<T>(
+    fn: () => Promise<T>,
+    options: RetryOptions
+  ): Promise<T> {
+    const { maxRetries, delayMs, backoffFactor = 1.5, onRetry } = options;
+    let lastError: any;
+
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        return await fn();
+      } catch (error) {
+        lastError = error;
+        
+        if (attempt === maxRetries) {
+          throw error;
+        }
+
+        const delay = delayMs * Math.pow(backoffFactor, attempt - 1);
+        
+        if (onRetry) {
+          onRetry(error, attempt);
+        }
+
+        log_error(`Attempt ${attempt} failed. Retrying in ${delay}ms...`, error);
+        
+        await new Promise(resolve => setTimeout(resolve, delay));
+      }
+    }
+
+    throw lastError;
+  }
+
+  /**
+   * Execute database operations with retry logic
+   */
+  static async withDatabaseRetry<T>(
+    operation: () => Promise<T>,
+    operationName: string
+  ): Promise<T> {
+    return this.withRetry(operation, {
+      maxRetries: 3,
+      delayMs: 1000,
+      backoffFactor: 2,
+      onRetry: (error, attempt) => {
+        log_error(`Database operation '${operationName}' failed on attempt ${attempt}:`, error);
+      }
+    });
+  }
+
+  /**
+   * Check if an error is retryable
+   */
+  static isRetryableError(error: any): boolean {
+    // PostgreSQL error codes that are retryable
+    const retryableErrorCodes = [
+      '40001', // serialization_failure
+      '40P01', // deadlock_detected
+      '55P03', // lock_not_available
+      '57P01', // admin_shutdown
+      '57P02', // crash_shutdown
+      '57P03', // cannot_connect_now
+      '58000', // system_error
+      '58030', // io_error
+      '53000', // insufficient_resources
+      '53100', // disk_full
+      '53200', // out_of_memory
+      '53300', // too_many_connections
+      '53400', // configuration_limit_exceeded
+    ];
+
+    if (error.code && retryableErrorCodes.includes(error.code)) {
+      return true;
+    }
+
+    // Network-related errors
+    if (error.message && (
+      error.message.includes('ECONNRESET') ||
+      error.message.includes('ETIMEDOUT') ||
+      error.message.includes('ECONNREFUSED')
+    )) {
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Execute with conditional retry based on error type
+   */
+  static async withConditionalRetry<T>(
+    fn: () => Promise<T>,
+    options: RetryOptions
+  ): Promise<T> {
+    const { maxRetries, delayMs, backoffFactor = 1.5, onRetry } = options;
+    let lastError: any;
+
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        return await fn();
+      } catch (error) {
+        lastError = error;
+        
+        if (!this.isRetryableError(error) || attempt === maxRetries) {
+          throw error;
+        }
+
+        const delay = delayMs * Math.pow(backoffFactor, attempt - 1);
+        
+        if (onRetry) {
+          onRetry(error, attempt);
+        }
+
+        log_error(`Retryable error on attempt ${attempt}. Retrying in ${delay}ms...`, error);
+        
+        await new Promise(resolve => setTimeout(resolve, delay));
+      }
+    }
+
+    throw lastError;
+  }
+}
--- a/worklenz-backend/src/utils/timezone-utils.ts
+++ b/worklenz-backend/src/utils/timezone-utils.ts
@@ -0,0 +1,156 @@
+import moment from "moment-timezone";
+import { IRecurringSchedule } from "../interfaces/recurring-tasks";
+
+export class TimezoneUtils {
+  /**
+   * Convert a date from one timezone to another
+   */
+  static convertTimezone(date: moment.Moment | Date | string, fromTz: string, toTz: string): moment.Moment {
+    return moment.tz(date, fromTz).tz(toTz);
+  }
+
+  /**
+   * Get the current time in a specific timezone
+   */
+  static nowInTimezone(timezone: string): moment.Moment {
+    return moment.tz(timezone);
+  }
+
+  /**
+   * Check if a recurring task should run based on timezone
+   */
+  static shouldRunInTimezone(schedule: IRecurringSchedule, timezone: string): boolean {
+    const now = this.nowInTimezone(timezone);
+    const scheduleTime = moment.tz(schedule.created_at, timezone);
+    
+    // Check if it's the right time of day (within a 1-hour window)
+    const hourDiff = Math.abs(now.hour() - scheduleTime.hour());
+    return hourDiff < 1;
+  }
+
+  /**
+   * Calculate next end date considering timezone
+   */
+  static calculateNextEndDateWithTimezone(
+    schedule: IRecurringSchedule, 
+    lastDate: moment.Moment | Date | string,
+    timezone: string
+  ): moment.Moment {
+    const lastMoment = moment.tz(lastDate, timezone);
+    
+    switch (schedule.schedule_type) {
+      case "daily":
+        return lastMoment.clone().add(1, "day");
+        
+      case "weekly":
+        if (schedule.days_of_week && schedule.days_of_week.length > 0) {
+          // Find next occurrence based on selected days
+          let nextDate = lastMoment.clone();
+          let daysChecked = 0;
+          
+          do {
+            nextDate.add(1, "day");
+            daysChecked++;
+            if (schedule.days_of_week.includes(nextDate.day())) {
+              return nextDate;
+            }
+          } while (daysChecked < 7);
+          
+          // If no valid day found, return next week's first selected day
+          const sortedDays = [...schedule.days_of_week].sort((a, b) => a - b);
+          nextDate = lastMoment.clone().add(1, "week").day(sortedDays[0]);
+          return nextDate;
+        }
+        return lastMoment.clone().add(1, "week");
+        
+      case "monthly":
+        if (schedule.date_of_month) {
+          // Specific date of month
+          let nextDate = lastMoment.clone().add(1, "month").date(schedule.date_of_month);
+          
+          // Handle months with fewer days
+          if (nextDate.date() !== schedule.date_of_month) {
+            nextDate = nextDate.endOf("month");
+          }
+          
+          return nextDate;
+        } else if (schedule.week_of_month && schedule.day_of_month !== undefined) {
+          // Nth occurrence of a day in month
+          const nextMonth = lastMoment.clone().add(1, "month").startOf("month");
+          const targetDay = schedule.day_of_month;
+          const targetWeek = schedule.week_of_month;
+          
+          // Find first occurrence of the target day
+          let firstOccurrence = nextMonth.clone();
+          while (firstOccurrence.day() !== targetDay) {
+            firstOccurrence.add(1, "day");
+          }
+          
+          // Calculate nth occurrence
+          if (targetWeek === 5) {
+            // Last occurrence
+            let lastOccurrence = firstOccurrence.clone();
+            let temp = firstOccurrence.clone().add(7, "days");
+            
+            while (temp.month() === nextMonth.month()) {
+              lastOccurrence = temp.clone();
+              temp.add(7, "days");
+            }
+            
+            return lastOccurrence;
+          } else {
+            // Specific week number
+            return firstOccurrence.add((targetWeek - 1) * 7, "days");
+          }
+        }
+        return lastMoment.clone().add(1, "month");
+        
+      case "every_x_days":
+        return lastMoment.clone().add(schedule.interval_days || 1, "days");
+        
+      case "every_x_weeks":
+        return lastMoment.clone().add(schedule.interval_weeks || 1, "weeks");
+        
+      case "every_x_months":
+        return lastMoment.clone().add(schedule.interval_months || 1, "months");
+        
+      default:
+        return lastMoment.clone().add(1, "day");
+    }
+  }
+
+  /**
+   * Get all timezones that should be processed in the current hour
+   */
+  static getActiveTimezones(): string[] {
+    const activeTimezones: string[] = [];
+    const allTimezones = moment.tz.names();
+    
+    for (const tz of allTimezones) {
+      const tzTime = moment.tz(tz);
+      // Check if it's 11:00 AM in this timezone (matching the cron schedule)
+      if (tzTime.hour() === 11) {
+        activeTimezones.push(tz);
+      }
+    }
+    
+    return activeTimezones;
+  }
+
+  /**
+   * Validate timezone string
+   */
+  static isValidTimezone(timezone: string): boolean {
+    return moment.tz.zone(timezone) !== null;
+  }
+
+  /**
+   * Get user's timezone or default to UTC
+   */
+  static getUserTimezone(userTimezone?: string): string {
+    if (userTimezone && this.isValidTimezone(userTimezone)) {
+      return userTimezone;
+    }
+    return "UTC";
+  }
+}
--- a/worklenz-frontend/src/app/routes/main-routes.tsx
+++ b/worklenz-frontend/src/app/routes/main-routes.tsx
@@ -17,7 +17,6 @@ const ProjectTemplateEditView = lazy(
 const LicenseExpired = lazy(() => import('@/pages/license-expired/license-expired'));
 const ProjectView = lazy(() => import('@/pages/projects/projectView/project-view'));
 const Unauthorized = lazy(() => import('@/pages/unauthorized/unauthorized'));
-const GanttDemoPage = lazy(() => import('@/pages/GanttDemoPage'));

 // Define AdminGuard component with defensive programming
 const AdminGuard = ({ children }: { children: React.ReactNode }) => {
@@ -107,14 +106,6 @@ const mainRoutes: RouteObject[] = [
          </Suspense>
        ),
      },
-      {
-        path: 'gantt-demo',
-        element: (
-          <Suspense fallback={<SuspenseFallback />}>
-            <GanttDemoPage />
-          </Suspense>
-        ),
-      },
      ...settingsRoutes,
      ...adminCenterRoutes,
    ],
--- a/worklenz-frontend/src/components/advanced-gantt/AdvancedGanttChart.tsx
+++ b/worklenz-frontend/src/components/advanced-gantt/AdvancedGanttChart.tsx
@@ -1,612 +0,0 @@
-import React, { useReducer, useMemo, useCallback, useRef, useEffect, useState } from 'react';
-import { 
-  GanttTask, 
-  ColumnConfig, 
-  TimelineConfig, 
-  VirtualScrollConfig,
-  ZoomLevel,
-  GanttState,
-  GanttAction,
-  AdvancedGanttProps,
-  SelectionState,
-  GanttViewState,
-  DragState
-} from '../../types/advanced-gantt.types';
-import GanttGrid from './GanttGrid';
-import DraggableTaskBar from './DraggableTaskBar';
-import TimelineMarkers, { holidayPresets, workingDayPresets } from './TimelineMarkers';
-import VirtualScrollContainer, { VirtualTimeline } from './VirtualScrollContainer';
-import { 
-  usePerformanceMonitoring, 
-  useTaskCalculations, 
-  useDateCalculations,
-  useDebounce,
-  useThrottle
-} from '../../utils/gantt-performance';
-import { useAppSelector } from '../../hooks/useAppSelector';
-import { themeWiseColor } from '../../utils/themeWiseColor';
-
-// Default configurations
-const defaultColumns: ColumnConfig[] = [
-  { 
-    field: 'name', 
-    title: 'Task Name', 
-    width: 250, 
-    minWidth: 150, 
-    resizable: true, 
-    sortable: true, 
-    fixed: true,
-    editor: 'text'
-  },
-  { 
-    field: 'startDate', 
-    title: 'Start Date', 
-    width: 120, 
-    minWidth: 100, 
-    resizable: true, 
-    sortable: true, 
-    fixed: true,
-    editor: 'date'
-  },
-  { 
-    field: 'endDate', 
-    title: 'End Date', 
-    width: 120, 
-    minWidth: 100, 
-    resizable: true, 
-    sortable: true, 
-    fixed: true,
-    editor: 'date'
-  },
-  { 
-    field: 'duration', 
-    title: 'Duration', 
-    width: 80, 
-    minWidth: 60, 
-    resizable: true, 
-    sortable: false, 
-    fixed: true 
-  },
-  { 
-    field: 'progress', 
-    title: 'Progress', 
-    width: 100, 
-    minWidth: 80, 
-    resizable: true, 
-    sortable: true, 
-    fixed: true,
-    editor: 'number'
-  },
-];
-
-const defaultTimelineConfig: TimelineConfig = {
-  topTier: { unit: 'month', format: 'MMM yyyy', height: 30 },
-  bottomTier: { unit: 'day', format: 'dd', height: 25 },
-  showWeekends: true,
-  showNonWorkingDays: true,
-  holidays: holidayPresets.US,
-  workingDays: workingDayPresets.standard,
-  workingHours: { start: 9, end: 17 },
-  dayWidth: 30,
-};
-
-const defaultVirtualScrollConfig: VirtualScrollConfig = {
-  enableRowVirtualization: true,
-  enableTimelineVirtualization: true,
-  bufferSize: 10,
-  itemHeight: 40,
-  overscan: 5,
-};
-
-const defaultZoomLevels: ZoomLevel[] = [
-  { 
-    name: 'Year', 
-    dayWidth: 2, 
-    scale: 0.1,
-    topTier: { unit: 'year', format: 'yyyy' },
-    bottomTier: { unit: 'month', format: 'MMM' }
-  },
-  { 
-    name: 'Month', 
-    dayWidth: 8, 
-    scale: 0.5,
-    topTier: { unit: 'month', format: 'MMM yyyy' },
-    bottomTier: { unit: 'week', format: 'w' }
-  },
-  { 
-    name: 'Week', 
-    dayWidth: 25, 
-    scale: 1,
-    topTier: { unit: 'week', format: 'MMM dd' },
-    bottomTier: { unit: 'day', format: 'dd' }
-  },
-  { 
-    name: 'Day', 
-    dayWidth: 50, 
-    scale: 2,
-    topTier: { unit: 'day', format: 'MMM dd' },
-    bottomTier: { unit: 'hour', format: 'HH' }
-  },
-];
-
-// Gantt state reducer
-function ganttReducer(state: GanttState, action: GanttAction): GanttState {
-  switch (action.type) {
-    case 'SET_TASKS':
-      return { ...state, tasks: action.payload };
-    
-    case 'UPDATE_TASK':
-      return {
-        ...state,
-        tasks: state.tasks.map(task =>
-          task.id === action.payload.id
-            ? { ...task, ...action.payload.updates }
-            : task
-        ),
-      };
-    
-    case 'ADD_TASK':
-      return { ...state, tasks: [...state.tasks, action.payload] };
-    
-    case 'DELETE_TASK':
-      return {
-        ...state,
-        tasks: state.tasks.filter(task => task.id !== action.payload),
-      };
-    
-    case 'SET_SELECTION':
-      return {
-        ...state,
-        selectionState: { ...state.selectionState, selectedTasks: action.payload },
-      };
-    
-    case 'SET_DRAG_STATE':
-      return { ...state, dragState: action.payload };
-    
-    case 'SET_ZOOM_LEVEL':
-      const newZoomLevel = Math.max(0, Math.min(state.zoomLevels.length - 1, action.payload));
-      return {
-        ...state,
-        viewState: { ...state.viewState, zoomLevel: newZoomLevel },
-        timelineConfig: {
-          ...state.timelineConfig,
-          dayWidth: state.zoomLevels[newZoomLevel].dayWidth,
-          topTier: state.zoomLevels[newZoomLevel].topTier,
-          bottomTier: state.zoomLevels[newZoomLevel].bottomTier,
-        },
-      };
-    
-    case 'SET_SCROLL_POSITION':
-      return {
-        ...state,
-        viewState: { ...state.viewState, scrollPosition: action.payload },
-      };
-    
-    case 'SET_SPLITTER_POSITION':
-      return {
-        ...state,
-        viewState: { ...state.viewState, splitterPosition: action.payload },
-      };
-    
-    case 'TOGGLE_TASK_EXPANSION':
-      return {
-        ...state,
-        tasks: state.tasks.map(task =>
-          task.id === action.payload
-            ? { ...task, isExpanded: !task.isExpanded }
-            : task
-        ),
-      };
-    
-    case 'SET_VIEW_STATE':
-      return {
-        ...state,
-        viewState: { ...state.viewState, ...action.payload },
-      };
-    
-    case 'UPDATE_COLUMN_WIDTH':
-      return {
-        ...state,
-        columns: state.columns.map(col =>
-          col.field === action.payload.field
-            ? { ...col, width: action.payload.width }
-            : col
-        ),
-      };
-    
-    default:
-      return state;
-  }
-}
-
-const AdvancedGanttChart: React.FC<AdvancedGanttProps> = ({
-  tasks: initialTasks,
-  columns = defaultColumns,
-  timelineConfig = {},
-  virtualScrollConfig = {},
-  zoomLevels = defaultZoomLevels,
-  initialViewState = {},
-  initialSelection = [],
-  onTaskUpdate,
-  onTaskCreate,
-  onTaskDelete,
-  onTaskMove,
-  onTaskResize,
-  onProgressChange,
-  onSelectionChange,
-  onColumnResize,
-  onDependencyCreate,
-  onDependencyDelete,
-  className = '',
-  style = {},
-  theme = 'auto',
-  enableDragDrop = true,
-  enableResize = true,
-  enableProgressEdit = true,
-  enableInlineEdit = true,
-  enableVirtualScrolling = true,
-  enableDebouncing = true,
-  debounceDelay = 300,
-  maxVisibleTasks = 1000,
-}) => {
-  const containerRef = useRef<HTMLDivElement>(null);
-  const [containerSize, setContainerSize] = useState({ width: 0, height: 0 });
-  const themeMode = useAppSelector(state => state.themeReducer.mode);
-  const { startMeasure, endMeasure, metrics } = usePerformanceMonitoring();
-  const { getDaysBetween } = useDateCalculations();
-
-  // Initialize state
-  const initialState: GanttState = {
-    tasks: initialTasks,
-    columns,
-    timelineConfig: { ...defaultTimelineConfig, ...timelineConfig },
-    virtualScrollConfig: { ...defaultVirtualScrollConfig, ...virtualScrollConfig },
-    dragState: null,
-    selectionState: {
-      selectedTasks: initialSelection,
-      selectedRows: [],
-      focusedTask: undefined,
-    },
-    viewState: {
-      zoomLevel: 2, // Week view by default
-      scrollPosition: { x: 0, y: 0 },
-      viewportSize: { width: 0, height: 0 },
-      splitterPosition: 40, // 40% for grid, 60% for timeline
-      showCriticalPath: false,
-      showBaseline: false,
-      showProgress: true,
-      showDependencies: true,
-      autoSchedule: false,
-      readOnly: false,
-      ...initialViewState,
-    },
-    zoomLevels,
-    performanceMetrics: {
-      renderTime: 0,
-      taskCount: initialTasks.length,
-      visibleTaskCount: 0,
-    },
-  };
-
-  const [state, dispatch] = useReducer(ganttReducer, initialState);
-  const { taskMap, parentChildMap, totalTasks } = useTaskCalculations(state.tasks);
-
-  // Calculate project timeline bounds
-  const projectBounds = useMemo(() => {
-    if (state.tasks.length === 0) {
-      const today = new Date();
-      return {
-        start: new Date(today.getFullYear(), today.getMonth(), 1),
-        end: new Date(today.getFullYear(), today.getMonth() + 3, 0),
-      };
-    }
-
-    const startDates = state.tasks.map(task => task.startDate);
-    const endDates = state.tasks.map(task => task.endDate);
-    const minStart = new Date(Math.min(...startDates.map(d => d.getTime())));
-    const maxEnd = new Date(Math.max(...endDates.map(d => d.getTime())));
-
-    // Add some padding
-    minStart.setDate(minStart.getDate() - 7);
-    maxEnd.setDate(maxEnd.getDate() + 7);
-
-    return { start: minStart, end: maxEnd };
-  }, [state.tasks]);
-
-  // Debounced event handlers
-  const debouncedTaskUpdate = useDebounce(
-    useCallback((taskId: string, updates: Partial<GanttTask>) => {
-      dispatch({ type: 'UPDATE_TASK', payload: { id: taskId, updates } });
-      onTaskUpdate?.(taskId, updates);
-    }, [onTaskUpdate]),
-    enableDebouncing ? debounceDelay : 0
-  );
-
-  const debouncedTaskMove = useDebounce(
-    useCallback((taskId: string, newDates: { start: Date; end: Date }) => {
-      dispatch({ type: 'UPDATE_TASK', payload: { 
-        id: taskId, 
-        updates: { startDate: newDates.start, endDate: newDates.end } 
-      }});
-      onTaskMove?.(taskId, newDates);
-    }, [onTaskMove]),
-    enableDebouncing ? debounceDelay : 0
-  );
-
-  const debouncedProgressChange = useDebounce(
-    useCallback((taskId: string, progress: number) => {
-      dispatch({ type: 'UPDATE_TASK', payload: { id: taskId, updates: { progress } }});
-      onProgressChange?.(taskId, progress);
-    }, [onProgressChange]),
-    enableDebouncing ? debounceDelay : 0
-  );
-
-  // Throttled scroll handler
-  const throttledScrollHandler = useThrottle(
-    useCallback((scrollLeft: number, scrollTop: number) => {
-      dispatch({ type: 'SET_SCROLL_POSITION', payload: { x: scrollLeft, y: scrollTop } });
-    }, []),
-    16 // 60fps
-  );
-
-  // Container size observer
-  useEffect(() => {
-    const observer = new ResizeObserver((entries) => {
-      for (const entry of entries) {
-        const { width, height } = entry.contentRect;
-        setContainerSize({ width, height });
-        dispatch({ 
-          type: 'SET_VIEW_STATE', 
-          payload: { viewportSize: { width, height } } 
-        });
-      }
-    });
-
-    if (containerRef.current) {
-      observer.observe(containerRef.current);
-    }
-
-    return () => observer.disconnect();
-  }, []);
-
-  // Calculate grid and timeline dimensions
-  const gridWidth = useMemo(() => {
-    return Math.floor(containerSize.width * (state.viewState.splitterPosition / 100));
-  }, [containerSize.width, state.viewState.splitterPosition]);
-
-  const timelineWidth = useMemo(() => {
-    return containerSize.width - gridWidth;
-  }, [containerSize.width, gridWidth]);
-
-  // Handle zoom changes
-  const handleZoomChange = useCallback((direction: 'in' | 'out') => {
-    const currentZoom = state.viewState.zoomLevel;
-    const newZoom = direction === 'in' 
-      ? Math.min(state.zoomLevels.length - 1, currentZoom + 1)
-      : Math.max(0, currentZoom - 1);
-    
-    dispatch({ type: 'SET_ZOOM_LEVEL', payload: newZoom });
-  }, [state.viewState.zoomLevel, state.zoomLevels.length]);
-
-  // Theme-aware colors
-  const colors = useMemo(() => ({
-    background: themeWiseColor('#ffffff', '#1f2937', themeMode),
-    border: themeWiseColor('#e5e7eb', '#4b5563', themeMode),
-    timelineBackground: themeWiseColor('#f8f9fa', '#374151', themeMode),
-  }), [themeMode]);
-
-  // Render timeline header
-  const renderTimelineHeader = () => {
-    const currentZoom = state.zoomLevels[state.viewState.zoomLevel];
-    const totalDays = getDaysBetween(projectBounds.start, projectBounds.end);
-    const totalWidth = totalDays * state.timelineConfig.dayWidth;
-
-    return (
-      <div className="timeline-header border-b" style={{ 
-        height: (currentZoom.topTier.height || 30) + (currentZoom.bottomTier.height || 25),
-        backgroundColor: colors.timelineBackground,
-        borderColor: colors.border,
-      }}>
-        <VirtualTimeline
-          startDate={projectBounds.start}
-          endDate={projectBounds.end}
-          dayWidth={state.timelineConfig.dayWidth}
-          containerWidth={timelineWidth}
-          containerHeight={(currentZoom.topTier.height || 30) + (currentZoom.bottomTier.height || 25)}
-          onScroll={throttledScrollHandler}
-        >
-          {(date, index, style) => (
-            <div className="timeline-cell flex flex-col border-r text-xs text-center" style={{
-              ...style,
-              borderColor: colors.border,
-            }}>
-              <div className="top-tier border-b px-1 py-1" style={{
-                height: currentZoom.topTier.height || 30,
-                borderColor: colors.border,
-              }}>
-                {formatDateForUnit(date, currentZoom.topTier.unit)}
-              </div>
-              <div className="bottom-tier px-1 py-1" style={{
-                height: currentZoom.bottomTier.height || 25,
-              }}>
-                {formatDateForUnit(date, currentZoom.bottomTier.unit)}
-              </div>
-            </div>
-          )}
-        </VirtualTimeline>
-      </div>
-    );
-  };
-
-  // Render timeline content
-  const renderTimelineContent = () => {
-    const headerHeight = (state.zoomLevels[state.viewState.zoomLevel].topTier.height || 30) + 
-                        (state.zoomLevels[state.viewState.zoomLevel].bottomTier.height || 25);
-    const contentHeight = containerSize.height - headerHeight;
-
-    return (
-      <div className="timeline-content relative" style={{ height: contentHeight }}>
-        {/* Timeline markers (weekends, holidays, etc.) */}
-        <TimelineMarkers
-          startDate={projectBounds.start}
-          endDate={projectBounds.end}
-          dayWidth={state.timelineConfig.dayWidth}
-          containerHeight={contentHeight}
-          timelineConfig={state.timelineConfig}
-          holidays={state.timelineConfig.holidays}
-          showWeekends={state.timelineConfig.showWeekends}
-          showHolidays={true}
-          showToday={true}
-        />
-
-        {/* Task bars */}
-        <VirtualScrollContainer
-          items={state.tasks}
-          itemHeight={state.virtualScrollConfig.itemHeight}
-          containerHeight={contentHeight}
-          containerWidth={timelineWidth}
-          overscan={state.virtualScrollConfig.overscan}
-          onScroll={throttledScrollHandler}
-        >
-          {(task, index, style) => (
-            <DraggableTaskBar
-              key={task.id}
-              task={task}
-              timelineStart={projectBounds.start}
-              dayWidth={state.timelineConfig.dayWidth}
-              rowHeight={state.virtualScrollConfig.itemHeight}
-              index={index}
-              onTaskMove={debouncedTaskMove}
-              onTaskResize={debouncedTaskMove}
-              onProgressChange={debouncedProgressChange}
-              enableDragDrop={enableDragDrop}
-              enableResize={enableResize}
-              enableProgressEdit={enableProgressEdit}
-              readOnly={state.viewState.readOnly}
-            />
-          )}
-        </VirtualScrollContainer>
-      </div>
-    );
-  };
-
-  // Render toolbar
-  const renderToolbar = () => (
-    <div className="gantt-toolbar flex items-center justify-between p-2 border-b bg-gray-50 dark:bg-gray-800" style={{
-      borderColor: colors.border,
-    }}>
-      <div className="toolbar-left flex items-center space-x-2">
-        <button
-          onClick={() => handleZoomChange('out')}
-          disabled={state.viewState.zoomLevel === 0}
-          className="px-2 py-1 text-sm border rounded hover:bg-gray-100 dark:hover:bg-gray-700 disabled:opacity-50"
-        >
-          Zoom Out
-        </button>
-        <span className="text-sm text-gray-600 dark:text-gray-400">
-          {state.zoomLevels[state.viewState.zoomLevel].name}
-        </span>
-        <button
-          onClick={() => handleZoomChange('in')}
-          disabled={state.viewState.zoomLevel === state.zoomLevels.length - 1}
-          className="px-2 py-1 text-sm border rounded hover:bg-gray-100 dark:hover:bg-gray-700 disabled:opacity-50"
-        >
-          Zoom In
-        </button>
-      </div>
-      
-      <div className="toolbar-right flex items-center space-x-2 text-xs text-gray-500">
-        <span>Tasks: {state.tasks.length}</span>
-        <span>•</span>
-        <span>Render: {Math.round(metrics.renderTime)}ms</span>
-      </div>
-    </div>
-  );
-
-  // Performance monitoring
-  useEffect(() => {
-    startMeasure('render');
-    return () => endMeasure('render');
-  });
-
-  return (
-    <div
-      ref={containerRef}
-      className={`advanced-gantt-chart flex flex-col ${className}`}
-      style={{
-        height: '100%',
-        backgroundColor: colors.background,
-        ...style,
-      }}
-    >
-      {/* Toolbar */}
-      {renderToolbar()}
-
-      {/* Main content */}
-      <div className="gantt-content flex flex-1 overflow-hidden">
-        {/* Grid */}
-        <div className="gantt-grid-container" style={{ width: gridWidth }}>
-          <GanttGrid
-            tasks={state.tasks}
-            columns={state.columns}
-            rowHeight={state.virtualScrollConfig.itemHeight}
-            containerHeight={containerSize.height - 50} // Subtract toolbar height
-            selection={state.selectionState}
-            enableInlineEdit={enableInlineEdit}
-            onTaskClick={(task) => {
-              // Handle task selection
-              const newSelection = { ...state.selectionState, selectedTasks: [task.id] };
-              dispatch({ type: 'SET_SELECTION', payload: [task.id] });
-              onSelectionChange?.(newSelection);
-            }}
-            onTaskExpand={(taskId) => {
-              dispatch({ type: 'TOGGLE_TASK_EXPANSION', payload: taskId });
-            }}
-            onColumnResize={(field, width) => {
-              dispatch({ type: 'UPDATE_COLUMN_WIDTH', payload: { field, width } });
-              onColumnResize?.(field, width);
-            }}
-            onTaskUpdate={debouncedTaskUpdate}
-          />
-        </div>
-
-        {/* Timeline */}
-        <div className="gantt-timeline-container border-l" style={{ 
-          width: timelineWidth,
-          borderColor: colors.border,
-        }}>
-          {renderTimelineHeader()}
-          {renderTimelineContent()}
-        </div>
-      </div>
-    </div>
-  );
-};
-
-// Helper function to format dates based on unit
-function formatDateForUnit(date: Date, unit: string): string {
-  switch (unit) {
-    case 'year':
-      return date.getFullYear().toString();
-    case 'month':
-      return date.toLocaleDateString('en-US', { month: 'short', year: 'numeric' });
-    case 'week':
-      return `W${getWeekNumber(date)}`;
-    case 'day':
-      return date.getDate().toString();
-    case 'hour':
-      return date.getHours().toString().padStart(2, '0');
-    default:
-      return '';
-  }
-}
-
-function getWeekNumber(date: Date): number {
-  const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
-  const dayNum = d.getUTCDay() || 7;
-  d.setUTCDate(d.getUTCDate() + 4 - dayNum);
-  const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
-  return Math.ceil((((d.getTime() - yearStart.getTime()) / 86400000) + 1) / 7);
-}
-
-export default AdvancedGanttChart;
--- a/worklenz-frontend/src/components/advanced-gantt/AdvancedGanttDemo.tsx
+++ b/worklenz-frontend/src/components/advanced-gantt/AdvancedGanttDemo.tsx
@@ -1,668 +0,0 @@
-import React, { useState, useMemo } from 'react';
-import { Button, Space, message, Card } from 'antd';
-import AdvancedGanttChart from './AdvancedGanttChart';
-import { GanttTask, ColumnConfig } from '../../types/advanced-gantt.types';
-import { useAppSelector } from '../../hooks/useAppSelector';
-import { holidayPresets, workingDayPresets } from './TimelineMarkers';
-
-// Enhanced sample data with more realistic project structure
-const generateSampleTasks = (): GanttTask[] => {
-  const baseDate = new Date(2024, 11, 1); // December 1, 2024
-  
-  return [
-    // Project Phase 1: Planning & Design
-    {
-      id: 'project-1',
-      name: '🚀 Web Platform Development',
-      startDate: new Date(2024, 11, 1),
-      endDate: new Date(2025, 2, 31),
-      progress: 45,
-      type: 'project',
-      status: 'in-progress',
-      priority: 'high',
-      color: '#1890ff',
-      hasChildren: true,
-      isExpanded: true,
-      level: 0,
-    },
-    {
-      id: 'planning-phase',
-      name: '📋 Planning & Analysis Phase',
-      startDate: new Date(2024, 11, 1),
-      endDate: new Date(2024, 11, 20),
-      progress: 85,
-      type: 'project',
-      status: 'in-progress',
-      priority: 'high',
-      parent: 'project-1',
-      color: '#52c41a',
-      hasChildren: true,
-      isExpanded: true,
-      level: 1,
-    },
-    {
-      id: 'requirements-analysis',
-      name: 'Requirements Gathering & Analysis',
-      startDate: new Date(2024, 11, 1),
-      endDate: new Date(2024, 11, 8),
-      progress: 100,
-      type: 'task',
-      status: 'completed',
-      priority: 'high',
-      parent: 'planning-phase',
-      assignee: {
-        id: 'user-1',
-        name: 'Alice Johnson',
-        avatar: 'https://ui-avatars.com/api/?name=Alice+Johnson&background=1890ff&color=fff',
-      },
-      tags: ['research', 'documentation'],
-      level: 2,
-    },
-    {
-      id: 'technical-architecture',
-      name: 'Technical Architecture Design',
-      startDate: new Date(2024, 11, 8),
-      endDate: new Date(2024, 11, 18),
-      progress: 75,
-      type: 'task',
-      status: 'in-progress',
-      priority: 'high',
-      parent: 'planning-phase',
-      assignee: {
-        id: 'user-2',
-        name: 'Bob Smith',
-        avatar: 'https://ui-avatars.com/api/?name=Bob+Smith&background=52c41a&color=fff',
-      },
-      dependencies: ['requirements-analysis'],
-      tags: ['architecture', 'design'],
-      level: 2,
-    },
-    {
-      id: 'ui-ux-design',
-      name: 'UI/UX Design & Prototyping',
-      startDate: new Date(2024, 11, 10),
-      endDate: new Date(2024, 11, 20),
-      progress: 60,
-      type: 'task',
-      status: 'in-progress',
-      priority: 'medium',
-      parent: 'planning-phase',
-      assignee: {
-        id: 'user-3',
-        name: 'Carol Davis',
-        avatar: 'https://ui-avatars.com/api/?name=Carol+Davis&background=faad14&color=fff',
-      },
-      dependencies: ['requirements-analysis'],
-      tags: ['design', 'prototype'],
-      level: 2,
-    },
-    {
-      id: 'milestone-planning-complete',
-      name: '🎯 Planning Phase Complete',
-      startDate: new Date(2024, 11, 20),
-      endDate: new Date(2024, 11, 20),
-      progress: 0,
-      type: 'milestone',
-      status: 'not-started',
-      priority: 'critical',
-      parent: 'planning-phase',
-      dependencies: ['technical-architecture', 'ui-ux-design'],
-      level: 2,
-    },
-
-    // Development Phase
-    {
-      id: 'development-phase',
-      name: '⚡ Development Phase',
-      startDate: new Date(2024, 11, 21),
-      endDate: new Date(2025, 1, 28),
-      progress: 35,
-      type: 'project',
-      status: 'in-progress',
-      priority: 'high',
-      parent: 'project-1',
-      color: '#722ed1',
-      hasChildren: true,
-      isExpanded: true,
-      level: 1,
-    },
-    {
-      id: 'backend-development',
-      name: 'Backend API Development',
-      startDate: new Date(2024, 11, 21),
-      endDate: new Date(2025, 1, 15),
-      progress: 45,
-      type: 'task',
-      status: 'in-progress',
-      priority: 'high',
-      parent: 'development-phase',
-      assignee: {
-        id: 'user-4',
-        name: 'David Wilson',
-        avatar: 'https://ui-avatars.com/api/?name=David+Wilson&background=722ed1&color=fff',
-      },
-      dependencies: ['milestone-planning-complete'],
-      tags: ['backend', 'api'],
-      level: 2,
-    },
-    {
-      id: 'frontend-development',
-      name: 'Frontend React Application',
-      startDate: new Date(2025, 0, 5),
-      endDate: new Date(2025, 1, 25),
-      progress: 25,
-      type: 'task',
-      status: 'in-progress',
-      priority: 'high',
-      parent: 'development-phase',
-      assignee: {
-        id: 'user-5',
-        name: 'Eva Brown',
-        avatar: 'https://ui-avatars.com/api/?name=Eva+Brown&background=ff7a45&color=fff',
-      },
-      dependencies: ['backend-development'],
-      tags: ['frontend', 'react'],
-      level: 2,
-    },
-    {
-      id: 'database-setup',
-      name: 'Database Schema & Migration',
-      startDate: new Date(2024, 11, 21),
-      endDate: new Date(2025, 0, 10),
-      progress: 80,
-      type: 'task',
-      status: 'in-progress',
-      priority: 'medium',
-      parent: 'development-phase',
-      assignee: {
-        id: 'user-6',
-        name: 'Frank Miller',
-        avatar: 'https://ui-avatars.com/api/?name=Frank+Miller&background=13c2c2&color=fff',
-      },
-      dependencies: ['milestone-planning-complete'],
-      tags: ['database', 'migration'],
-      level: 2,
-    },
-
-    // Testing Phase
-    {
-      id: 'testing-phase',
-      name: '🧪 Testing & QA Phase',
-      startDate: new Date(2025, 2, 1),
-      endDate: new Date(2025, 2, 20),
-      progress: 0,
-      type: 'project',
-      status: 'not-started',
-      priority: 'high',
-      parent: 'project-1',
-      color: '#fa8c16',
-      hasChildren: true,
-      isExpanded: false,
-      level: 1,
-    },
-    {
-      id: 'unit-testing',
-      name: 'Unit Testing Implementation',
-      startDate: new Date(2025, 2, 1),
-      endDate: new Date(2025, 2, 10),
-      progress: 0,
-      type: 'task',
-      status: 'not-started',
-      priority: 'high',
-      parent: 'testing-phase',
-      assignee: {
-        id: 'user-7',
-        name: 'Grace Lee',
-        avatar: 'https://ui-avatars.com/api/?name=Grace+Lee&background=fa8c16&color=fff',
-      },
-      dependencies: ['frontend-development'],
-      tags: ['testing', 'unit'],
-      level: 2,
-    },
-    {
-      id: 'integration-testing',
-      name: 'Integration & E2E Testing',
-      startDate: new Date(2025, 2, 8),
-      endDate: new Date(2025, 2, 18),
-      progress: 0,
-      type: 'task',
-      status: 'not-started',
-      priority: 'high',
-      parent: 'testing-phase',
-      assignee: {
-        id: 'user-8',
-        name: 'Henry Clark',
-        avatar: 'https://ui-avatars.com/api/?name=Henry+Clark&background=eb2f96&color=fff',
-      },
-      dependencies: ['unit-testing'],
-      tags: ['testing', 'integration'],
-      level: 2,
-    },
-    {
-      id: 'milestone-beta-ready',
-      name: '🎯 Beta Release Ready',
-      startDate: new Date(2025, 2, 20),
-      endDate: new Date(2025, 2, 20),
-      progress: 0,
-      type: 'milestone',
-      status: 'not-started',
-      priority: 'critical',
-      parent: 'testing-phase',
-      dependencies: ['integration-testing'],
-      level: 2,
-    },
-
-    // Deployment Phase
-    {
-      id: 'deployment-phase',
-      name: '🚀 Deployment & Launch',
-      startDate: new Date(2025, 2, 21),
-      endDate: new Date(2025, 2, 31),
-      progress: 0,
-      type: 'project',
-      status: 'not-started',
-      priority: 'critical',
-      parent: 'project-1',
-      color: '#f5222d',
-      hasChildren: true,
-      isExpanded: false,
-      level: 1,
-    },
-    {
-      id: 'production-deployment',
-      name: 'Production Environment Setup',
-      startDate: new Date(2025, 2, 21),
-      endDate: new Date(2025, 2, 25),
-      progress: 0,
-      type: 'task',
-      status: 'not-started',
-      priority: 'critical',
-      parent: 'deployment-phase',
-      assignee: {
-        id: 'user-9',
-        name: 'Ivy Taylor',
-        avatar: 'https://ui-avatars.com/api/?name=Ivy+Taylor&background=f5222d&color=fff',
-      },
-      dependencies: ['milestone-beta-ready'],
-      tags: ['deployment', 'production'],
-      level: 2,
-    },
-    {
-      id: 'go-live',
-      name: 'Go Live & Monitoring',
-      startDate: new Date(2025, 2, 26),
-      endDate: new Date(2025, 2, 31),
-      progress: 0,
-      type: 'task',
-      status: 'not-started',
-      priority: 'critical',
-      parent: 'deployment-phase',
-      assignee: {
-        id: 'user-10',
-        name: 'Jack Anderson',
-        avatar: 'https://ui-avatars.com/api/?name=Jack+Anderson&background=2f54eb&color=fff',
-      },
-      dependencies: ['production-deployment'],
-      tags: ['launch', 'monitoring'],
-      level: 2,
-    },
-    {
-      id: 'milestone-project-complete',
-      name: '🎉 Project Launch Complete',
-      startDate: new Date(2025, 2, 31),
-      endDate: new Date(2025, 2, 31),
-      progress: 0,
-      type: 'milestone',
-      status: 'not-started',
-      priority: 'critical',
-      parent: 'deployment-phase',
-      dependencies: ['go-live'],
-      level: 2,
-    },
-  ];
-};
-
-// Enhanced column configuration
-const sampleColumns: ColumnConfig[] = [
-  { 
-    field: 'name', 
-    title: 'Task / Phase Name', 
-    width: 300, 
-    minWidth: 200, 
-    resizable: true, 
-    sortable: true, 
-    fixed: true,
-    editor: 'text'
-  },
-  { 
-    field: 'assignee', 
-    title: 'Assignee', 
-    width: 150, 
-    minWidth: 120, 
-    resizable: true, 
-    sortable: true, 
-    fixed: true 
-  },
-  { 
-    field: 'startDate', 
-    title: 'Start Date', 
-    width: 120, 
-    minWidth: 100, 
-    resizable: true, 
-    sortable: true, 
-    fixed: true,
-    editor: 'date'
-  },
-  { 
-    field: 'endDate', 
-    title: 'End Date', 
-    width: 120, 
-    minWidth: 100, 
-    resizable: true, 
-    sortable: true, 
-    fixed: true,
-    editor: 'date'
-  },
-  { 
-    field: 'duration', 
-    title: 'Duration', 
-    width: 80, 
-    minWidth: 60, 
-    resizable: true, 
-    sortable: false, 
-    fixed: true,
-    align: 'center'
-  },
-  { 
-    field: 'progress', 
-    title: 'Progress', 
-    width: 120, 
-    minWidth: 100, 
-    resizable: true, 
-    sortable: true, 
-    fixed: true,
-    editor: 'number'
-  },
-  { 
-    field: 'status', 
-    title: 'Status', 
-    width: 100, 
-    minWidth: 80, 
-    resizable: true, 
-    sortable: true, 
-    fixed: true,
-    editor: 'select',
-    editorOptions: [
-      { value: 'not-started', label: 'Not Started' },
-      { value: 'in-progress', label: 'In Progress' },
-      { value: 'completed', label: 'Completed' },
-      { value: 'on-hold', label: 'On Hold' },
-      { value: 'overdue', label: 'Overdue' },
-    ]
-  },
-  { 
-    field: 'priority', 
-    title: 'Priority', 
-    width: 100, 
-    minWidth: 80, 
-    resizable: true, 
-    sortable: true, 
-    fixed: true,
-    editor: 'select',
-    editorOptions: [
-      { value: 'low', label: 'Low' },
-      { value: 'medium', label: 'Medium' },
-      { value: 'high', label: 'High' },
-      { value: 'critical', label: 'Critical' },
-    ]
-  },
-];
-
-const AdvancedGanttDemo: React.FC = () => {
-  const [tasks, setTasks] = useState<GanttTask[]>(generateSampleTasks());
-  const [selectedTasks, setSelectedTasks] = useState<string[]>([]);
-  const themeMode = useAppSelector(state => state.themeReducer.mode);
-
-  const handleTaskUpdate = (taskId: string, updates: Partial<GanttTask>) => {
-    setTasks(prevTasks => 
-      prevTasks.map(task => 
-        task.id === taskId ? { ...task, ...updates } : task
-      )
-    );
-    message.success(`Task "${tasks.find(t => t.id === taskId)?.name}" updated`);
-  };
-
-  const handleTaskMove = (taskId: string, newDates: { start: Date; end: Date }) => {
-    setTasks(prevTasks => 
-      prevTasks.map(task => 
-        task.id === taskId 
-          ? { ...task, startDate: newDates.start, endDate: newDates.end }
-          : task
-      )
-    );
-    message.info(`Task moved: ${newDates.start.toLocaleDateString()} - ${newDates.end.toLocaleDateString()}`);
-  };
-
-  const handleProgressChange = (taskId: string, progress: number) => {
-    setTasks(prevTasks => 
-      prevTasks.map(task => 
-        task.id === taskId ? { ...task, progress } : task
-      )
-    );
-    message.info(`Progress updated: ${Math.round(progress)}%`);
-  };
-
-  const handleSelectionChange = (selection: any) => {
-    setSelectedTasks(selection.selectedTasks);
-  };
-
-  const resetToSampleData = () => {
-    setTasks(generateSampleTasks());
-    setSelectedTasks([]);
-    message.info('Gantt chart reset to sample data');
-  };
-
-  const addSampleTask = () => {
-    const newTask: GanttTask = {
-      id: `task-${Date.now()}`,
-      name: `New Task ${tasks.length + 1}`,
-      startDate: new Date(),
-      endDate: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000), // +7 days
-      progress: 0,
-      type: 'task',
-      status: 'not-started',
-      priority: 'medium',
-      level: 0,
-    };
-    setTasks(prev => [...prev, newTask]);
-    message.success('New task added');
-  };
-
-  const deleteSelectedTasks = () => {
-    if (selectedTasks.length === 0) {
-      message.warning('No tasks selected');
-      return;
-    }
-    
-    setTasks(prev => prev.filter(task => !selectedTasks.includes(task.id)));
-    setSelectedTasks([]);
-    message.success(`${selectedTasks.length} task(s) deleted`);
-  };
-
-  const taskStats = useMemo(() => {
-    const total = tasks.length;
-    const completed = tasks.filter(t => t.status === 'completed').length;
-    const inProgress = tasks.filter(t => t.status === 'in-progress').length;
-    const overdue = tasks.filter(t => t.status === 'overdue').length;
-    const avgProgress = tasks.reduce((sum, t) => sum + t.progress, 0) / total;
-
-    return { total, completed, inProgress, overdue, avgProgress };
-  }, [tasks]);
-
-  return (
-    <div className="advanced-gantt-demo p-6 bg-gray-50 dark:bg-gray-900 min-h-screen">
-      {/* Header */}
-      <div className="bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded-lg shadow-sm mb-4">
-        <div className="p-6">
-          <div className="flex justify-between items-start mb-4">
-            <div>
-              <h1 className="text-3xl font-bold text-gray-900 dark:text-gray-100 mb-2">
-                🚀 Advanced Gantt Chart Demo
-              </h1>
-              <p className="text-gray-600 dark:text-gray-400 mb-4">
-                Professional Gantt chart with draggable tasks, virtual scrolling, holiday markers, 
-                and performance optimizations for modern project management.
-              </p>
-            </div>
-            
-            <div className="flex flex-col items-end space-y-2">
-              <Space>
-                <Button 
-                  onClick={addSampleTask}
-                  type="primary"
-                  className="dark:border-gray-600"
-                >
-                  Add Task
-                </Button>
-                <Button 
-                  onClick={deleteSelectedTasks}
-                  danger
-                  disabled={selectedTasks.length === 0}
-                  className="dark:border-gray-600"
-                >
-                  Delete Selected ({selectedTasks.length})
-                </Button>
-                <Button 
-                  onClick={resetToSampleData}
-                  className="dark:border-gray-600 dark:text-gray-300"
-                >
-                  Reset Data
-                </Button>
-              </Space>
-            </div>
-          </div>
-
-          {/* Project Statistics */}
-          <div className="grid grid-cols-2 md:grid-cols-4 gap-4">
-            <div className="bg-blue-50 dark:bg-blue-900 dark:bg-opacity-20 rounded-lg p-3">
-              <div className="text-blue-600 dark:text-blue-400 text-sm font-medium">Total Tasks</div>
-              <div className="text-2xl font-bold text-blue-700 dark:text-blue-300">{taskStats.total}</div>
-            </div>
-            <div className="bg-green-50 dark:bg-green-900 dark:bg-opacity-20 rounded-lg p-3">
-              <div className="text-green-600 dark:text-green-400 text-sm font-medium">Completed</div>
-              <div className="text-2xl font-bold text-green-700 dark:text-green-300">{taskStats.completed}</div>
-            </div>
-            <div className="bg-yellow-50 dark:bg-yellow-900 dark:bg-opacity-20 rounded-lg p-3">
-              <div className="text-yellow-600 dark:text-yellow-400 text-sm font-medium">In Progress</div>
-              <div className="text-2xl font-bold text-yellow-700 dark:text-yellow-300">{taskStats.inProgress}</div>
-            </div>
-            <div className="bg-purple-50 dark:bg-purple-900 dark:bg-opacity-20 rounded-lg p-3">
-              <div className="text-purple-600 dark:text-purple-400 text-sm font-medium">Avg Progress</div>
-              <div className="text-2xl font-bold text-purple-700 dark:text-purple-300">
-                {Math.round(taskStats.avgProgress)}%
-              </div>
-            </div>
-          </div>
-        </div>
-      </div>
-
-      {/* Gantt Chart */}
-      <div className="bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded-lg shadow-sm" style={{ height: '70vh' }}>
-        <AdvancedGanttChart
-          tasks={tasks}
-          columns={sampleColumns}
-          timelineConfig={{
-            showWeekends: true,
-            showNonWorkingDays: true,
-            holidays: holidayPresets.US,
-            workingDays: workingDayPresets.standard,
-            dayWidth: 30,
-          }}
-          onTaskUpdate={handleTaskUpdate}
-          onTaskMove={handleTaskMove}
-          onProgressChange={handleProgressChange}
-          onSelectionChange={handleSelectionChange}
-          enableDragDrop={true}
-          enableResize={true}
-          enableProgressEdit={true}
-          enableInlineEdit={true}
-          enableVirtualScrolling={true}
-          className="h-full"
-        />
-      </div>
-
-      {/* Feature List */}
-      <div className="bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded-lg shadow-sm mt-4">
-        <div className="p-6">
-          <h3 className="text-lg font-semibold text-gray-900 dark:text-gray-100 mb-3">
-            ✨ Advanced Features Demonstrated
-          </h3>
-          <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4 text-sm">
-            <div className="space-y-2">
-              <h4 className="font-medium text-gray-900 dark:text-gray-100">Performance & UX</h4>
-              <ul className="space-y-1 text-gray-600 dark:text-gray-400">
-                <li>• Virtual scrolling for 1000+ tasks</li>
-                <li>• Smooth 60fps drag & drop</li>
-                <li>• Debounced updates</li>
-                <li>• Memory-optimized rendering</li>
-                <li>• Responsive design</li>
-              </ul>
-            </div>
-            <div className="space-y-2">
-              <h4 className="font-medium text-gray-900 dark:text-gray-100">Gantt Features</h4>
-              <ul className="space-y-1 text-gray-600 dark:text-gray-400">
-                <li>• Draggable task bars</li>
-                <li>• Resizable task duration</li>
-                <li>• Progress editing</li>
-                <li>• Multi-level hierarchy</li>
-                <li>• Task dependencies</li>
-              </ul>
-            </div>
-            <div className="space-y-2">
-              <h4 className="font-medium text-gray-900 dark:text-gray-100">Timeline & Markers</h4>
-              <ul className="space-y-1 text-gray-600 dark:text-gray-400">
-                <li>• Weekend & holiday markers</li>
-                <li>• Working day indicators</li>
-                <li>• Today line</li>
-                <li>• Multi-tier timeline</li>
-                <li>• Zoom levels (Year/Month/Week/Day)</li>
-              </ul>
-            </div>
-            <div className="space-y-2">
-              <h4 className="font-medium text-gray-900 dark:text-gray-100">Grid Features</h4>
-              <ul className="space-y-1 text-gray-600 dark:text-gray-400">
-                <li>• Fixed columns layout</li>
-                <li>• Inline editing</li>
-                <li>• Column resizing</li>
-                <li>• Multi-select</li>
-                <li>• Hierarchical tree view</li>
-              </ul>
-            </div>
-            <div className="space-y-2">
-              <h4 className="font-medium text-gray-900 dark:text-gray-100">UI/UX</h4>
-              <ul className="space-y-1 text-gray-600 dark:text-gray-400">
-                <li>• Dark/Light theme support</li>
-                <li>• Tailwind CSS styling</li>
-                <li>• Consistent with Worklenz</li>
-                <li>• Accessibility features</li>
-                <li>• Mobile responsive</li>
-              </ul>
-            </div>
-            <div className="space-y-2">
-              <h4 className="font-medium text-gray-900 dark:text-gray-100">Architecture</h4>
-              <ul className="space-y-1 text-gray-600 dark:text-gray-400">
-                <li>• Modern React patterns</li>
-                <li>• TypeScript safety</li>
-                <li>• Optimized performance</li>
-                <li>• Enterprise features</li>
-                <li>• Best practices 2025</li>
-              </ul>
-            </div>
-          </div>
-        </div>
-      </div>
-    </div>
-  );
-};
-
-export default AdvancedGanttDemo;
--- a/worklenz-frontend/src/components/advanced-gantt/DraggableTaskBar.tsx
+++ b/worklenz-frontend/src/components/advanced-gantt/DraggableTaskBar.tsx
@@ -1,304 +0,0 @@
-import React, { useState, useRef, useCallback, useMemo } from 'react';
-import { GanttTask, DragState } from '../../types/advanced-gantt.types';
-import { useAppSelector } from '../../hooks/useAppSelector';
-import { themeWiseColor } from '../../utils/themeWiseColor';
-import { useDateCalculations } from '../../utils/gantt-performance';
-
-interface DraggableTaskBarProps {
-  task: GanttTask;
-  timelineStart: Date;
-  dayWidth: number;
-  rowHeight: number;
-  index: number;
-  onTaskMove?: (taskId: string, newDates: { start: Date; end: Date }) => void;
-  onTaskResize?: (taskId: string, newDates: { start: Date; end: Date }) => void;
-  onProgressChange?: (taskId: string, progress: number) => void;
-  onTaskClick?: (task: GanttTask) => void;
-  onTaskDoubleClick?: (task: GanttTask) => void;
-  enableDragDrop?: boolean;
-  enableResize?: boolean;
-  enableProgressEdit?: boolean;
-  readOnly?: boolean;
-}
-
-const DraggableTaskBar: React.FC<DraggableTaskBarProps> = ({
-  task,
-  timelineStart,
-  dayWidth,
-  rowHeight,
-  index,
-  onTaskMove,
-  onTaskResize,
-  onProgressChange,
-  onTaskClick,
-  onTaskDoubleClick,
-  enableDragDrop = true,
-  enableResize = true,
-  enableProgressEdit = true,
-  readOnly = false,
-}) => {
-  const [dragState, setDragState] = useState<DragState | null>(null);
-  const [hoverState, setHoverState] = useState<string | null>(null);
-  const taskBarRef = useRef<HTMLDivElement>(null);
-  const themeMode = useAppSelector(state => state.themeReducer.mode);
-  const { getDaysBetween, addDays } = useDateCalculations();
-
-  // Calculate task position and dimensions
-  const taskPosition = useMemo(() => {
-    const startDays = getDaysBetween(timelineStart, task.startDate);
-    const duration = getDaysBetween(task.startDate, task.endDate);
-    
-    return {
-      x: startDays * dayWidth,
-      width: Math.max(dayWidth * 0.5, duration * dayWidth),
-      y: index * rowHeight + 8, // 8px padding
-      height: rowHeight - 16, // 16px total padding
-    };
-  }, [task.startDate, task.endDate, timelineStart, dayWidth, rowHeight, index, getDaysBetween]);
-
-  // Theme-aware colors
-  const colors = useMemo(() => {
-    const baseColor = task.color || getDefaultTaskColor(task.status);
-    return {
-      background: themeWiseColor(baseColor, adjustColorForDarkMode(baseColor), themeMode),
-      border: themeWiseColor(darkenColor(baseColor, 0.2), lightenColor(baseColor, 0.2), themeMode),
-      progress: themeWiseColor('#52c41a', '#34d399', themeMode),
-      text: themeWiseColor('#ffffff', '#f9fafb', themeMode),
-      hover: themeWiseColor(lightenColor(baseColor, 0.1), darkenColor(baseColor, 0.1), themeMode),
-    };
-  }, [task.color, task.status, themeMode]);
-
-  // Mouse event handlers
-  const handleMouseDown = useCallback((e: React.MouseEvent, dragType: DragState['dragType']) => {
-    if (readOnly || !enableDragDrop) return;
-    
-    e.preventDefault();
-    e.stopPropagation();
-
-    const rect = taskBarRef.current?.getBoundingClientRect();
-    if (!rect) return;
-
-    setDragState({
-      isDragging: true,
-      dragType,
-      taskId: task.id,
-      initialPosition: { x: e.clientX, y: e.clientY },
-      currentPosition: { x: e.clientX, y: e.clientY },
-      initialDates: { start: task.startDate, end: task.endDate },
-      initialProgress: task.progress,
-      snapToGrid: true,
-    });
-
-    // Add global mouse event listeners
-    const handleMouseMove = (moveEvent: MouseEvent) => {
-      handleMouseMove_Internal(moveEvent, dragType);
-    };
-
-    const handleMouseUp = () => {
-      handleMouseUp_Internal();
-      document.removeEventListener('mousemove', handleMouseMove);
-      document.removeEventListener('mouseup', handleMouseUp);
-    };
-
-    document.addEventListener('mousemove', handleMouseMove);
-    document.addEventListener('mouseup', handleMouseUp);
-  }, [readOnly, enableDragDrop, task]);
-
-  const handleMouseMove_Internal = useCallback((e: MouseEvent, dragType: DragState['dragType']) => {
-    if (!dragState) return;
-
-    const deltaX = e.clientX - dragState.initialPosition.x;
-    const deltaDays = Math.round(deltaX / dayWidth);
-
-    let newStartDate = task.startDate;
-    let newEndDate = task.endDate;
-
-    switch (dragType) {
-      case 'move':
-        newStartDate = addDays(dragState.initialDates.start, deltaDays);
-        newEndDate = addDays(dragState.initialDates.end, deltaDays);
-        break;
-      
-      case 'resize-start':
-        newStartDate = addDays(dragState.initialDates.start, deltaDays);
-        // Ensure minimum duration
-        if (newStartDate >= newEndDate) {
-          newStartDate = addDays(newEndDate, -1);
-        }
-        break;
-      
-      case 'resize-end':
-        newEndDate = addDays(dragState.initialDates.end, deltaDays);
-        // Ensure minimum duration
-        if (newEndDate <= newStartDate) {
-          newEndDate = addDays(newStartDate, 1);
-        }
-        break;
-      
-      case 'progress':
-        if (enableProgressEdit) {
-          const progressDelta = deltaX / taskPosition.width;
-          const newProgress = Math.max(0, Math.min(100, (dragState.initialProgress || 0) + progressDelta * 100));
-          onProgressChange?.(task.id, newProgress);
-        }
-        return;
-    }
-
-    // Update drag state
-    setDragState(prev => prev ? {
-      ...prev,
-      currentPosition: { x: e.clientX, y: e.clientY },
-    } : null);
-
-    // Call appropriate handler
-    if (dragType === 'move') {
-      onTaskMove?.(task.id, { start: newStartDate, end: newEndDate });
-    } else if (dragType.startsWith('resize')) {
-      onTaskResize?.(task.id, { start: newStartDate, end: newEndDate });
-    }
-  }, [dragState, dayWidth, task, taskPosition.width, enableProgressEdit, onTaskMove, onTaskResize, onProgressChange, addDays]);
-
-  const handleMouseUp_Internal = useCallback(() => {
-    setDragState(null);
-  }, []);
-
-  const handleClick = useCallback((e: React.MouseEvent) => {
-    e.stopPropagation();
-    onTaskClick?.(task);
-  }, [task, onTaskClick]);
-
-  const handleDoubleClick = useCallback((e: React.MouseEvent) => {
-    e.stopPropagation();
-    onTaskDoubleClick?.(task);
-  }, [task, onTaskDoubleClick]);
-
-  // Render task bar with handles
-  const renderTaskBar = () => {
-    const isSelected = false; // TODO: Get from selection state
-    const isDragging = dragState?.isDragging || false;
-
-    return (
-      <div
-        ref={taskBarRef}
-        className={`task-bar relative cursor-pointer select-none transition-all duration-200 ${
-          isDragging ? 'z-10 shadow-lg' : ''
-        } ${isSelected ? 'ring-2 ring-blue-500 ring-opacity-50' : ''}`}
-        style={{
-          position: 'absolute',
-          left: taskPosition.x,
-          top: taskPosition.y,
-          width: taskPosition.width,
-          height: taskPosition.height,
-          backgroundColor: dragState?.isDragging ? colors.hover : colors.background,
-          border: `1px solid ${colors.border}`,
-          borderRadius: '4px',
-          transform: isDragging ? 'translateY(-2px)' : 'none',
-          boxShadow: isDragging ? '0 4px 12px rgba(0,0,0,0.15)' : '0 1px 3px rgba(0,0,0,0.1)',
-        }}
-        onClick={handleClick}
-        onDoubleClick={handleDoubleClick}
-        onMouseEnter={() => setHoverState('task')}
-        onMouseLeave={() => setHoverState(null)}
-        onMouseDown={(e) => handleMouseDown(e, 'move')}
-      >
-        {/* Progress bar */}
-        <div
-          className="progress-bar absolute inset-0 rounded-l"
-          style={{
-            width: `${task.progress}%`,
-            backgroundColor: colors.progress,
-            opacity: 0.7,
-            borderRadius: '3px 0 0 3px',
-          }}
-        />
-
-        {/* Task content */}
-        <div className="task-content relative z-10 h-full flex items-center px-2">
-          <span
-            className="task-name text-xs font-medium truncate"
-            style={{ color: colors.text }}
-          >
-            {task.name}
-          </span>
-          
-          {/* Duration display for smaller tasks */}
-          {taskPosition.width < 100 && (
-            <span
-              className="task-duration text-xs ml-auto"
-              style={{ color: colors.text, opacity: 0.8 }}
-            >
-              {getDaysBetween(task.startDate, task.endDate)}d
-            </span>
-          )}
-        </div>
-
-        {/* Resize handles */}
-        {enableResize && !readOnly && hoverState === 'task' && (
-          <>
-            {/* Left resize handle */}
-            <div
-              className="resize-handle-left absolute left-0 top-0 w-1 h-full cursor-ew-resize bg-white bg-opacity-50 hover:bg-opacity-80"
-              onMouseDown={(e) => handleMouseDown(e, 'resize-start')}
-              onMouseEnter={() => setHoverState('resize-start')}
-            />
-            
-            {/* Right resize handle */}
-            <div
-              className="resize-handle-right absolute right-0 top-0 w-1 h-full cursor-ew-resize bg-white bg-opacity-50 hover:bg-opacity-80"
-              onMouseDown={(e) => handleMouseDown(e, 'resize-end')}
-              onMouseEnter={() => setHoverState('resize-end')}
-            />
-          </>
-        )}
-
-        {/* Progress handle */}
-        {enableProgressEdit && !readOnly && hoverState === 'task' && (
-          <div
-            className="progress-handle absolute top-0 h-full w-1 cursor-ew-resize bg-blue-500 opacity-75"
-            style={{ left: `${task.progress}%` }}
-            onMouseDown={(e) => handleMouseDown(e, 'progress')}
-            onMouseEnter={() => setHoverState('progress')}
-          />
-        )}
-
-        {/* Task type indicator */}
-        {task.type === 'milestone' && (
-          <div
-            className="milestone-indicator absolute -top-1 -right-1 w-3 h-3 transform rotate-45"
-            style={{ backgroundColor: colors.border }}
-          />
-        )}
-      </div>
-    );
-  };
-
-  return renderTaskBar();
-};
-
-// Helper functions
-function getDefaultTaskColor(status: GanttTask['status']): string {
-  switch (status) {
-    case 'completed': return '#52c41a';
-    case 'in-progress': return '#1890ff';
-    case 'overdue': return '#ff4d4f';
-    case 'on-hold': return '#faad14';
-    default: return '#d9d9d9';
-  }
-}
-
-function darkenColor(color: string, amount: number): string {
-  // Simple color darkening - in a real app, use a proper color manipulation library
-  return color;
-}
-
-function lightenColor(color: string, amount: number): string {
-  // Simple color lightening - in a real app, use a proper color manipulation library
-  return color;
-}
-
-function adjustColorForDarkMode(color: string): string {
-  // Adjust color for dark mode - in a real app, use a proper color manipulation library
-  return color;
-}
-
-export default DraggableTaskBar;
--- a/worklenz-frontend/src/components/advanced-gantt/GanttGrid.tsx
+++ b/worklenz-frontend/src/components/advanced-gantt/GanttGrid.tsx
@@ -1,492 +0,0 @@
-import React, { useMemo, useRef, useState, useCallback } from 'react';
-import { GanttTask, ColumnConfig, SelectionState } from '../../types/advanced-gantt.types';
-import { useAppSelector } from '../../hooks/useAppSelector';
-import { themeWiseColor } from '../../utils/themeWiseColor';
-import { ChevronRightIcon, ChevronDownIcon } from '@heroicons/react/24/outline';
-import { CalendarIcon, UserIcon, FlagIcon } from '@heroicons/react/24/solid';
-
-interface GanttGridProps {
-  tasks: GanttTask[];
-  columns: ColumnConfig[];
-  rowHeight: number;
-  containerHeight: number;
-  selection: SelectionState;
-  enableInlineEdit?: boolean;
-  enableMultiSelect?: boolean;
-  onTaskClick?: (task: GanttTask, event: React.MouseEvent) => void;
-  onTaskDoubleClick?: (task: GanttTask) => void;
-  onTaskExpand?: (taskId: string) => void;
-  onSelectionChange?: (selection: SelectionState) => void;
-  onColumnResize?: (columnField: string, newWidth: number) => void;
-  onTaskUpdate?: (taskId: string, field: string, value: any) => void;
-  className?: string;
-}
-
-const GanttGrid: React.FC<GanttGridProps> = ({
-  tasks,
-  columns,
-  rowHeight,
-  containerHeight,
-  selection,
-  enableInlineEdit = true,
-  enableMultiSelect = true,
-  onTaskClick,
-  onTaskDoubleClick,
-  onTaskExpand,
-  onSelectionChange,
-  onColumnResize,
-  onTaskUpdate,
-  className = '',
-}) => {
-  const [editingCell, setEditingCell] = useState<{ taskId: string; field: string } | null>(null);
-  const [columnWidths, setColumnWidths] = useState<Record<string, number>>(
-    columns.reduce((acc, col) => ({ ...acc, [col.field]: col.width }), {})
-  );
-  const gridRef = useRef<HTMLDivElement>(null);
-  const themeMode = useAppSelector(state => state.themeReducer.mode);
-
-  // Theme-aware colors
-  const colors = useMemo(() => ({
-    background: themeWiseColor('#ffffff', '#1f2937', themeMode),
-    alternateRow: themeWiseColor('#f9fafb', '#374151', themeMode),
-    border: themeWiseColor('#e5e7eb', '#4b5563', themeMode),
-    text: themeWiseColor('#111827', '#f9fafb', themeMode),
-    textSecondary: themeWiseColor('#6b7280', '#d1d5db', themeMode),
-    selected: themeWiseColor('#eff6ff', '#1e3a8a', themeMode),
-    hover: themeWiseColor('#f3f4f6', '#4b5563', themeMode),
-    headerBg: themeWiseColor('#f8f9fa', '#374151', themeMode),
-  }), [themeMode]);
-
-  // Calculate total grid width
-  const totalWidth = useMemo(() => {
-    return columns.reduce((sum, col) => sum + columnWidths[col.field], 0);
-  }, [columns, columnWidths]);
-
-  // Handle column resize
-  const handleColumnResize = useCallback((columnField: string, deltaX: number) => {
-    const column = columns.find(col => col.field === columnField);
-    if (!column) return;
-
-    const currentWidth = columnWidths[columnField];
-    const newWidth = Math.max(column.minWidth || 60, Math.min(column.maxWidth || 400, currentWidth + deltaX));
-    
-    setColumnWidths(prev => ({ ...prev, [columnField]: newWidth }));
-    onColumnResize?.(columnField, newWidth);
-  }, [columns, columnWidths, onColumnResize]);
-
-  // Handle task selection
-  const handleTaskSelection = useCallback((task: GanttTask, event: React.MouseEvent) => {
-    const { ctrlKey, shiftKey } = event;
-    let newSelectedTasks = [...selection.selectedTasks];
-
-    if (shiftKey && enableMultiSelect && selection.selectedTasks.length > 0) {
-      // Range selection
-      const lastSelectedIndex = tasks.findIndex(t => t.id === selection.selectedTasks[selection.selectedTasks.length - 1]);
-      const currentIndex = tasks.findIndex(t => t.id === task.id);
-      const [start, end] = [Math.min(lastSelectedIndex, currentIndex), Math.max(lastSelectedIndex, currentIndex)];
-      
-      newSelectedTasks = tasks.slice(start, end + 1).map(t => t.id);
-    } else if (ctrlKey && enableMultiSelect) {
-      // Multi selection
-      if (newSelectedTasks.includes(task.id)) {
-        newSelectedTasks = newSelectedTasks.filter(id => id !== task.id);
-      } else {
-        newSelectedTasks.push(task.id);
-      }
-    } else {
-      // Single selection
-      newSelectedTasks = [task.id];
-    }
-
-    onSelectionChange?.({
-      ...selection,
-      selectedTasks: newSelectedTasks,
-      focusedTask: task.id,
-    });
-
-    onTaskClick?.(task, event);
-  }, [tasks, selection, enableMultiSelect, onSelectionChange, onTaskClick]);
-
-  // Handle cell editing
-  const handleCellDoubleClick = useCallback((task: GanttTask, column: ColumnConfig) => {
-    if (!enableInlineEdit || !column.editor) return;
-    
-    setEditingCell({ taskId: task.id, field: column.field });
-  }, [enableInlineEdit]);
-
-  const handleCellEditComplete = useCallback((value: any) => {
-    if (!editingCell) return;
-    
-    onTaskUpdate?.(editingCell.taskId, editingCell.field, value);
-    setEditingCell(null);
-  }, [editingCell, onTaskUpdate]);
-
-  // Render cell content
-  const renderCellContent = useCallback((task: GanttTask, column: ColumnConfig) => {
-    const value = task[column.field as keyof GanttTask];
-    const isEditing = editingCell?.taskId === task.id && editingCell?.field === column.field;
-
-    if (isEditing) {
-      return renderCellEditor(value, column, handleCellEditComplete);
-    }
-
-    if (column.renderer) {
-      return column.renderer(value, task);
-    }
-
-    // Default renderers
-    switch (column.field) {
-      case 'name':
-        return (
-          <div className="flex items-center space-x-2">
-            {task.hasChildren && (
-              <button
-                onClick={(e) => {
-                  e.stopPropagation();
-                  onTaskExpand?.(task.id);
-                }}
-                className="p-0.5 hover:bg-gray-200 dark:hover:bg-gray-600 rounded"
-              >
-                {task.isExpanded ? (
-                  <ChevronDownIcon className="w-3 h-3" />
-                ) : (
-                  <ChevronRightIcon className="w-3 h-3" />
-                )}
-              </button>
-            )}
-            <div 
-              className="flex items-center space-x-2"
-              style={{ paddingLeft: `${(task.level || 0) * 16}px` }}
-            >
-              {getTaskTypeIcon(task.type)}
-              <span className="truncate font-medium">{task.name}</span>
-            </div>
-          </div>
-        );
-      
-      case 'startDate':
-      case 'endDate':
-        return (
-          <div className="flex items-center space-x-1">
-            <CalendarIcon className="w-3 h-3 text-gray-400" />
-            <span>{(value as Date)?.toLocaleDateString() || '-'}</span>
-          </div>
-        );
-      
-      case 'assignee':
-        return task.assignee ? (
-          <div className="flex items-center space-x-2">
-            {task.assignee.avatar ? (
-              <img 
-                src={task.assignee.avatar} 
-                alt={task.assignee.name}
-                className="w-6 h-6 rounded-full"
-              />
-            ) : (
-              <UserIcon className="w-6 h-6 text-gray-400" />
-            )}
-            <span className="truncate">{task.assignee.name}</span>
-          </div>
-        ) : (
-          <span className="text-gray-400">Unassigned</span>
-        );
-      
-      case 'progress':
-        return (
-          <div className="flex items-center space-x-2">
-            <div className="flex-1 bg-gray-200 dark:bg-gray-600 rounded-full h-2">
-              <div
-                className="bg-blue-500 h-2 rounded-full transition-all duration-300"
-                style={{ width: `${task.progress}%` }}
-              />
-            </div>
-            <span className="text-xs w-8 text-right">{task.progress}%</span>
-          </div>
-        );
-      
-      case 'status':
-        return (
-          <span className={`px-2 py-1 rounded-full text-xs font-medium ${getStatusColor(task.status)}`}>
-            {task.status.replace('-', ' ')}
-          </span>
-        );
-      
-      case 'priority':
-        return (
-          <div className="flex items-center space-x-1">
-            <FlagIcon className={`w-3 h-3 ${getPriorityColor(task.priority)}`} />
-            <span className="capitalize">{task.priority}</span>
-          </div>
-        );
-      
-      case 'duration':
-        const duration = task.duration || Math.ceil((task.endDate.getTime() - task.startDate.getTime()) / (1000 * 60 * 60 * 24));
-        return <span>{duration}d</span>;
-      
-      default:
-        return <span>{String(value || '')}</span>;
-    }
-  }, [editingCell, onTaskExpand, handleCellEditComplete]);
-
-  // Render header
-  const renderHeader = () => (
-    <div 
-      className="grid-header flex border-b sticky top-0 z-10"
-      style={{ 
-        backgroundColor: colors.headerBg,
-        borderColor: colors.border,
-        height: rowHeight,
-      }}
-    >
-      {columns.map((column, index) => (
-        <div
-          key={column.field}
-          className="column-header flex items-center px-3 py-2 font-medium text-sm border-r relative group"
-          style={{
-            width: columnWidths[column.field],
-            borderColor: colors.border,
-            color: colors.text,
-          }}
-        >
-          <span className="truncate" title={column.title}>
-            {column.title}
-          </span>
-          
-          {/* Resize handle */}
-          {column.resizable && (
-            <ResizeHandle
-              onResize={(deltaX) => handleColumnResize(column.field, deltaX)}
-              className="absolute right-0 top-0 h-full w-1 cursor-col-resize hover:bg-blue-500 opacity-0 group-hover:opacity-100"
-            />
-          )}
-        </div>
-      ))}
-    </div>
-  );
-
-  // Render task rows
-  const renderRows = () => (
-    <div className="grid-body">
-      {tasks.map((task, rowIndex) => {
-        const isSelected = selection.selectedTasks.includes(task.id);
-        const isFocused = selection.focusedTask === task.id;
-        
-        return (
-          <div
-            key={task.id}
-            className={`grid-row flex border-b cursor-pointer hover:bg-opacity-75 ${
-              isSelected ? 'bg-blue-50 dark:bg-blue-900 bg-opacity-50' : 
-              rowIndex % 2 === 0 ? '' : 'bg-gray-50 dark:bg-gray-800 bg-opacity-30'
-            }`}
-            style={{
-              height: rowHeight,
-              borderColor: colors.border,
-              backgroundColor: isSelected ? colors.selected : 
-                              rowIndex % 2 === 0 ? 'transparent' : colors.alternateRow,
-            }}
-            onClick={(e) => handleTaskSelection(task, e)}
-            onDoubleClick={() => onTaskDoubleClick?.(task)}
-          >
-            {columns.map((column) => (
-              <div
-                key={`${task.id}-${column.field}`}
-                className="grid-cell flex items-center px-3 py-1 border-r overflow-hidden"
-                style={{
-                  width: columnWidths[column.field],
-                  borderColor: colors.border,
-                  textAlign: column.align || 'left',
-                }}
-                onDoubleClick={() => handleCellDoubleClick(task, column)}
-              >
-                {renderCellContent(task, column)}
-              </div>
-            ))}
-          </div>
-        );
-      })}
-    </div>
-  );
-
-  return (
-    <div
-      ref={gridRef}
-      className={`gantt-grid border-r ${className}`}
-      style={{
-        width: totalWidth,
-        height: containerHeight,
-        backgroundColor: colors.background,
-        borderColor: colors.border,
-      }}
-    >
-      {renderHeader()}
-      <div 
-        className="grid-content overflow-auto"
-        style={{ height: containerHeight - rowHeight }}
-      >
-        {renderRows()}
-      </div>
-    </div>
-  );
-};
-
-// Resize handle component
-interface ResizeHandleProps {
-  onResize: (deltaX: number) => void;
-  className?: string;
-}
-
-const ResizeHandle: React.FC<ResizeHandleProps> = ({ onResize, className }) => {
-  const [isDragging, setIsDragging] = useState(false);
-  const startXRef = useRef<number>(0);
-
-  const handleMouseDown = useCallback((e: React.MouseEvent) => {
-    e.preventDefault();
-    setIsDragging(true);
-    startXRef.current = e.clientX;
-
-    const handleMouseMove = (moveEvent: MouseEvent) => {
-      const deltaX = moveEvent.clientX - startXRef.current;
-      onResize(deltaX);
-      startXRef.current = moveEvent.clientX;
-    };
-
-    const handleMouseUp = () => {
-      setIsDragging(false);
-      document.removeEventListener('mousemove', handleMouseMove);
-      document.removeEventListener('mouseup', handleMouseUp);
-    };
-
-    document.addEventListener('mousemove', handleMouseMove);
-    document.addEventListener('mouseup', handleMouseUp);
-  }, [onResize]);
-
-  return (
-    <div
-      className={`resize-handle ${className} ${isDragging ? 'bg-blue-500' : ''}`}
-      onMouseDown={handleMouseDown}
-    />
-  );
-};
-
-// Cell editor component
-const renderCellEditor = (value: any, column: ColumnConfig, onComplete: (value: any) => void) => {
-  const [editValue, setEditValue] = useState(value);
-
-  const handleKeyDown = (e: React.KeyboardEvent) => {
-    if (e.key === 'Enter') {
-      onComplete(editValue);
-    } else if (e.key === 'Escape') {
-      onComplete(value); // Cancel editing
-    }
-  };
-
-  const handleBlur = () => {
-    onComplete(editValue);
-  };
-
-  switch (column.editor) {
-    case 'text':
-      return (
-        <input
-          type="text"
-          value={editValue}
-          onChange={(e) => setEditValue(e.target.value)}
-          onKeyDown={handleKeyDown}
-          onBlur={handleBlur}
-          className="w-full px-1 py-0.5 border rounded text-sm"
-          autoFocus
-        />
-      );
-    
-    case 'date':
-      return (
-        <input
-          type="date"
-          value={editValue instanceof Date ? editValue.toISOString().split('T')[0] : editValue}
-          onChange={(e) => setEditValue(new Date(e.target.value))}
-          onKeyDown={handleKeyDown}
-          onBlur={handleBlur}
-          className="w-full px-1 py-0.5 border rounded text-sm"
-          autoFocus
-        />
-      );
-    
-    case 'number':
-      return (
-        <input
-          type="number"
-          value={editValue}
-          onChange={(e) => setEditValue(parseFloat(e.target.value))}
-          onKeyDown={handleKeyDown}
-          onBlur={handleBlur}
-          className="w-full px-1 py-0.5 border rounded text-sm"
-          autoFocus
-        />
-      );
-    
-    case 'select':
-      return (
-        <select
-          value={editValue}
-          onChange={(e) => setEditValue(e.target.value)}
-          onKeyDown={handleKeyDown}
-          onBlur={handleBlur}
-          className="w-full px-1 py-0.5 border rounded text-sm"
-          autoFocus
-        >
-          {column.editorOptions?.map((option: any) => (
-            <option key={option.value} value={option.value}>
-              {option.label}
-            </option>
-          ))}
-        </select>
-      );
-    
-    default:
-      return <span>{String(value)}</span>;
-  }
-};
-
-// Helper functions
-const getTaskTypeIcon = (type: GanttTask['type']) => {
-  switch (type) {
-    case 'project':
-      return <div className="w-3 h-3 bg-blue-500 rounded-sm" />;
-    case 'milestone':
-      return <div className="w-3 h-3 bg-yellow-500 rotate-45" />;
-    default:
-      return <div className="w-3 h-3 bg-gray-400 rounded-full" />;
-  }
-};
-
-const getStatusColor = (status: GanttTask['status']) => {
-  switch (status) {
-    case 'completed':
-      return 'bg-green-100 text-green-800 dark:bg-green-900 dark:text-green-200';
-    case 'in-progress':
-      return 'bg-blue-100 text-blue-800 dark:bg-blue-900 dark:text-blue-200';
-    case 'overdue':
-      return 'bg-red-100 text-red-800 dark:bg-red-900 dark:text-red-200';
-    case 'on-hold':
-      return 'bg-yellow-100 text-yellow-800 dark:bg-yellow-900 dark:text-yellow-200';
-    default:
-      return 'bg-gray-100 text-gray-800 dark:bg-gray-700 dark:text-gray-200';
-  }
-};
-
-const getPriorityColor = (priority: GanttTask['priority']) => {
-  switch (priority) {
-    case 'critical':
-      return 'text-red-600';
-    case 'high':
-      return 'text-orange-500';
-    case 'medium':
-      return 'text-yellow-500';
-    case 'low':
-      return 'text-green-500';
-    default:
-      return 'text-gray-400';
-  }
-};
-
-export default GanttGrid;
--- a/worklenz-frontend/src/components/advanced-gantt/TimelineMarkers.tsx
+++ b/worklenz-frontend/src/components/advanced-gantt/TimelineMarkers.tsx
@@ -1,295 +0,0 @@
-import React, { useMemo } from 'react';
-import { Holiday, TimelineConfig } from '../../types/advanced-gantt.types';
-import { useAppSelector } from '../../hooks/useAppSelector';
-import { themeWiseColor } from '../../utils/themeWiseColor';
-import { useDateCalculations } from '../../utils/gantt-performance';
-
-interface TimelineMarkersProps {
-  startDate: Date;
-  endDate: Date;
-  dayWidth: number;
-  containerHeight: number;
-  timelineConfig: TimelineConfig;
-  holidays?: Holiday[];
-  showWeekends?: boolean;
-  showHolidays?: boolean;
-  showToday?: boolean;
-  className?: string;
-}
-
-const TimelineMarkers: React.FC<TimelineMarkersProps> = ({
-  startDate,
-  endDate,
-  dayWidth,
-  containerHeight,
-  timelineConfig,
-  holidays = [],
-  showWeekends = true,
-  showHolidays = true,
-  showToday = true,
-  className = '',
-}) => {
-  const themeMode = useAppSelector(state => state.themeReducer.mode);
-  const { getDaysBetween, isWeekend, isWorkingDay } = useDateCalculations();
-
-  // Generate all dates in the timeline
-  const timelineDates = useMemo(() => {
-    const dates: Date[] = [];
-    const totalDays = getDaysBetween(startDate, endDate);
-    
-    for (let i = 0; i <= totalDays; i++) {
-      const date = new Date(startDate);
-      date.setDate(date.getDate() + i);
-      dates.push(date);
-    }
-    
-    return dates;
-  }, [startDate, endDate, getDaysBetween]);
-
-  // Theme-aware colors
-  const colors = useMemo(() => ({
-    weekend: themeWiseColor('rgba(0, 0, 0, 0.05)', 'rgba(255, 255, 255, 0.05)', themeMode),
-    nonWorkingDay: themeWiseColor('rgba(0, 0, 0, 0.03)', 'rgba(255, 255, 255, 0.03)', themeMode),
-    holiday: themeWiseColor('rgba(255, 107, 107, 0.1)', 'rgba(255, 107, 107, 0.15)', themeMode),
-    today: themeWiseColor('rgba(24, 144, 255, 0.15)', 'rgba(64, 169, 255, 0.2)', themeMode),
-    todayLine: themeWiseColor('#1890ff', '#40a9ff', themeMode),
-    holidayBorder: themeWiseColor('#ff6b6b', '#ff8787', themeMode),
-  }), [themeMode]);
-
-  // Check if a date is a holiday
-  const isHoliday = (date: Date): Holiday | undefined => {
-    return holidays.find(holiday => {
-      if (holiday.recurring) {
-        return holiday.date.getMonth() === date.getMonth() && 
-               holiday.date.getDate() === date.getDate();
-      }
-      return holiday.date.toDateString() === date.toDateString();
-    });
-  };
-
-  // Check if date is today
-  const isToday = (date: Date): boolean => {
-    const today = new Date();
-    return date.toDateString() === today.toDateString();
-  };
-
-  // Render weekend markers
-  const renderWeekendMarkers = () => {
-    if (!showWeekends) return null;
-
-    return timelineDates.map((date, index) => {
-      if (!isWeekend(date)) return null;
-
-      return (
-        <div
-          key={`weekend-${index}`}
-          className="weekend-marker absolute top-0 pointer-events-none"
-          style={{
-            left: index * dayWidth,
-            width: dayWidth,
-            height: containerHeight,
-            backgroundColor: colors.weekend,
-            zIndex: 1,
-          }}
-        />
-      );
-    });
-  };
-
-  // Render non-working day markers
-  const renderNonWorkingDayMarkers = () => {
-    return timelineDates.map((date, index) => {
-      if (isWorkingDay(date, timelineConfig.workingDays)) return null;
-
-      return (
-        <div
-          key={`non-working-${index}`}
-          className="non-working-day-marker absolute top-0 pointer-events-none"
-          style={{
-            left: index * dayWidth,
-            width: dayWidth,
-            height: containerHeight,
-            backgroundColor: colors.nonWorkingDay,
-            zIndex: 1,
-          }}
-        />
-      );
-    });
-  };
-
-  // Render holiday markers
-  const renderHolidayMarkers = () => {
-    if (!showHolidays) return null;
-
-    return timelineDates.map((date, index) => {
-      const holiday = isHoliday(date);
-      if (!holiday) return null;
-
-      const holidayColor = holiday.color || colors.holiday;
-
-      return (
-        <div
-          key={`holiday-${index}`}
-          className="holiday-marker absolute top-0 pointer-events-none group"
-          style={{
-            left: index * dayWidth,
-            width: dayWidth,
-            height: containerHeight,
-            backgroundColor: holidayColor,
-            borderLeft: `2px solid ${colors.holidayBorder}`,
-            zIndex: 2,
-          }}
-        >
-          {/* Holiday tooltip */}
-          <div className="holiday-tooltip absolute top-0 left-1/2 transform -translate-x-1/2 -translate-y-full bg-gray-900 dark:bg-gray-100 text-white dark:text-gray-900 text-xs px-2 py-1 rounded opacity-0 group-hover:opacity-100 transition-opacity duration-200 whitespace-nowrap z-50">
-            <div className="font-medium">{holiday.name}</div>
-            <div className="text-xs opacity-75">{date.toLocaleDateString()}</div>
-            <div className="absolute top-full left-1/2 transform -translate-x-1/2 w-0 h-0 border-l-2 border-r-2 border-t-4 border-transparent border-t-gray-900 dark:border-t-gray-100"></div>
-          </div>
-
-          {/* Holiday icon */}
-          <div className="holiday-icon absolute top-1 left-1 w-3 h-3 rounded-full bg-red-500 opacity-75">
-            <div className="w-full h-full rounded-full animate-pulse"></div>
-          </div>
-        </div>
-      );
-    });
-  };
-
-  // Render today marker
-  const renderTodayMarker = () => {
-    if (!showToday) return null;
-
-    const todayIndex = timelineDates.findIndex(date => isToday(date));
-    if (todayIndex === -1) return null;
-
-    return (
-      <div
-        className="today-marker absolute top-0 pointer-events-none"
-        style={{
-          left: todayIndex * dayWidth,
-          width: dayWidth,
-          height: containerHeight,
-          backgroundColor: colors.today,
-          zIndex: 3,
-        }}
-      >
-        {/* Today line */}
-        <div
-          className="today-line absolute top-0 left-1/2 transform -translate-x-1/2"
-          style={{
-            width: '2px',
-            height: containerHeight,
-            backgroundColor: colors.todayLine,
-            zIndex: 4,
-          }}
-        />
-
-        {/* Today label */}
-        <div className="today-label absolute top-2 left-1/2 transform -translate-x-1/2 bg-blue-500 text-white text-xs px-2 py-1 rounded shadow-sm">
-          Today
-        </div>
-      </div>
-    );
-  };
-
-  // Render time period markers (quarters, months, etc.)
-  const renderTimePeriodMarkers = () => {
-    const markers: React.ReactNode[] = [];
-    const currentDate = new Date(startDate);
-    currentDate.setDate(1); // Start of month
-
-    while (currentDate <= endDate) {
-      const daysSinceStart = getDaysBetween(startDate, currentDate);
-      const isQuarterStart = currentDate.getMonth() % 3 === 0 && currentDate.getDate() === 1;
-      const isYearStart = currentDate.getMonth() === 0 && currentDate.getDate() === 1;
-
-      if (isYearStart) {
-        markers.push(
-          <div
-            key={`year-${currentDate.getTime()}`}
-            className="year-marker absolute top-0 border-l-2 border-blue-600 dark:border-blue-400"
-            style={{
-              left: daysSinceStart * dayWidth,
-              height: containerHeight,
-              zIndex: 5,
-            }}
-          >
-            <div className="year-label absolute top-2 left-1 bg-blue-600 dark:bg-blue-400 text-white text-xs px-1 py-0.5 rounded">
-              {currentDate.getFullYear()}
-            </div>
-          </div>
-        );
-      } else if (isQuarterStart) {
-        markers.push(
-          <div
-            key={`quarter-${currentDate.getTime()}`}
-            className="quarter-marker absolute top-0 border-l border-green-500 dark:border-green-400 opacity-60"
-            style={{
-              left: daysSinceStart * dayWidth,
-              height: containerHeight,
-              zIndex: 4,
-            }}
-          >
-            <div className="quarter-label absolute top-2 left-1 bg-green-500 dark:bg-green-400 text-white text-xs px-1 py-0.5 rounded">
-              Q{Math.floor(currentDate.getMonth() / 3) + 1}
-            </div>
-          </div>
-        );
-      }
-
-      // Move to next month
-      currentDate.setMonth(currentDate.getMonth() + 1);
-    }
-
-    return markers;
-  };
-
-  return (
-    <div className={`timeline-markers absolute inset-0 ${className}`}>
-      {renderNonWorkingDayMarkers()}
-      {renderWeekendMarkers()}
-      {renderHolidayMarkers()}
-      {renderTodayMarker()}
-      {renderTimePeriodMarkers()}
-    </div>
-  );
-};
-
-// Holiday presets for common countries
-export const holidayPresets = {
-  US: [
-    { date: new Date(2024, 0, 1), name: "New Year's Day", type: 'national' as const, recurring: true },
-    { date: new Date(2024, 0, 15), name: "Martin Luther King Jr. Day", type: 'national' as const, recurring: true },
-    { date: new Date(2024, 1, 19), name: "Presidents' Day", type: 'national' as const, recurring: true },
-    { date: new Date(2024, 4, 27), name: "Memorial Day", type: 'national' as const, recurring: true },
-    { date: new Date(2024, 5, 19), name: "Juneteenth", type: 'national' as const, recurring: true },
-    { date: new Date(2024, 6, 4), name: "Independence Day", type: 'national' as const, recurring: true },
-    { date: new Date(2024, 8, 2), name: "Labor Day", type: 'national' as const, recurring: true },
-    { date: new Date(2024, 9, 14), name: "Columbus Day", type: 'national' as const, recurring: true },
-    { date: new Date(2024, 10, 11), name: "Veterans Day", type: 'national' as const, recurring: true },
-    { date: new Date(2024, 10, 28), name: "Thanksgiving", type: 'national' as const, recurring: true },
-    { date: new Date(2024, 11, 25), name: "Christmas Day", type: 'national' as const, recurring: true },
-  ],
-  
-  UK: [
-    { date: new Date(2024, 0, 1), name: "New Year's Day", type: 'national' as const, recurring: true },
-    { date: new Date(2024, 2, 29), name: "Good Friday", type: 'religious' as const, recurring: false },
-    { date: new Date(2024, 3, 1), name: "Easter Monday", type: 'religious' as const, recurring: false },
-    { date: new Date(2024, 4, 6), name: "Early May Bank Holiday", type: 'national' as const, recurring: true },
-    { date: new Date(2024, 4, 27), name: "Spring Bank Holiday", type: 'national' as const, recurring: true },
-    { date: new Date(2024, 7, 26), name: "Summer Bank Holiday", type: 'national' as const, recurring: true },
-    { date: new Date(2024, 11, 25), name: "Christmas Day", type: 'religious' as const, recurring: true },
-    { date: new Date(2024, 11, 26), name: "Boxing Day", type: 'national' as const, recurring: true },
-  ],
-};
-
-// Working day presets
-export const workingDayPresets = {
-  standard: [1, 2, 3, 4, 5], // Monday to Friday
-  middle_east: [0, 1, 2, 3, 4], // Sunday to Thursday
-  six_day: [1, 2, 3, 4, 5, 6], // Monday to Saturday
-  four_day: [1, 2, 3, 4], // Monday to Thursday
-};
-
-export default TimelineMarkers;
--- a/worklenz-frontend/src/components/advanced-gantt/VirtualScrollContainer.tsx
+++ b/worklenz-frontend/src/components/advanced-gantt/VirtualScrollContainer.tsx
@@ -1,372 +0,0 @@
-import React, { useRef, useEffect, useState, useCallback, ReactNode } from 'react';
-import { useThrottle, usePerformanceMonitoring } from '../../utils/gantt-performance';
-import { useAppSelector } from '../../hooks/useAppSelector';
-
-interface VirtualScrollContainerProps {
-  items: any[];
-  itemHeight: number;
-  containerHeight: number;
-  containerWidth?: number;
-  overscan?: number;
-  horizontal?: boolean;
-  children: (item: any, index: number, style: React.CSSProperties) => ReactNode;
-  onScroll?: (scrollLeft: number, scrollTop: number) => void;
-  className?: string;
-  style?: React.CSSProperties;
-}
-
-const VirtualScrollContainer: React.FC<VirtualScrollContainerProps> = ({
-  items,
-  itemHeight,
-  containerHeight,
-  containerWidth = 0,
-  overscan = 5,
-  horizontal = false,
-  children,
-  onScroll,
-  className = '',
-  style = {},
-}) => {
-  const containerRef = useRef<HTMLDivElement>(null);
-  const [scrollTop, setScrollTop] = useState(0);
-  const [scrollLeft, setScrollLeft] = useState(0);
-  const { startMeasure, endMeasure, recordMetric } = usePerformanceMonitoring();
-  const themeMode = useAppSelector(state => state.themeReducer.mode);
-
-  // Calculate visible range
-  const totalHeight = items.length * itemHeight;
-  const startIndex = Math.max(0, Math.floor(scrollTop / itemHeight) - overscan);
-  const endIndex = Math.min(
-    items.length - 1,
-    Math.ceil((scrollTop + containerHeight) / itemHeight) + overscan
-  );
-  const visibleItems = items.slice(startIndex, endIndex + 1);
-  const offsetY = startIndex * itemHeight;
-
-  // Throttled scroll handler
-  const throttledScrollHandler = useThrottle(
-    useCallback((event: Event) => {
-      const target = event.target as HTMLDivElement;
-      const newScrollTop = target.scrollTop;
-      const newScrollLeft = target.scrollLeft;
-      
-      setScrollTop(newScrollTop);
-      setScrollLeft(newScrollLeft);
-      onScroll?.(newScrollLeft, newScrollTop);
-    }, [onScroll]),
-    16 // ~60fps
-  );
-
-  useEffect(() => {
-    const container = containerRef.current;
-    if (!container) return;
-
-    container.addEventListener('scroll', throttledScrollHandler, { passive: true });
-    
-    return () => {
-      container.removeEventListener('scroll', throttledScrollHandler);
-    };
-  }, [throttledScrollHandler]);
-
-  // Performance monitoring
-  useEffect(() => {
-    startMeasure('virtualScroll');
-    recordMetric('visibleTaskCount', visibleItems.length);
-    recordMetric('taskCount', items.length);
-    endMeasure('virtualScroll');
-  }, [visibleItems.length, items.length, startMeasure, endMeasure, recordMetric]);
-
-  const renderVisibleItems = () => {
-    return visibleItems.map((item, virtualIndex) => {
-      const actualIndex = startIndex + virtualIndex;
-      const itemStyle: React.CSSProperties = {
-        position: 'absolute',
-        top: horizontal ? 0 : actualIndex * itemHeight,
-        left: horizontal ? actualIndex * itemHeight : 0,
-        height: horizontal ? '100%' : itemHeight,
-        width: horizontal ? itemHeight : '100%',
-        transform: horizontal ? 'none' : `translateY(${offsetY}px)`,
-      };
-
-      return (
-        <div key={item.id || actualIndex} style={itemStyle}>
-          {children(item, actualIndex, itemStyle)}
-        </div>
-      );
-    });
-  };
-
-  return (
-    <div
-      ref={containerRef}
-      className={`virtual-scroll-container overflow-auto ${className}`}
-      style={{
-        height: containerHeight,
-        width: containerWidth || '100%',
-        position: 'relative',
-        ...style,
-      }}
-    >
-      {/* Spacer to maintain scroll height */}
-      <div
-        className="virtual-scroll-spacer"
-        style={{
-          height: horizontal ? '100%' : totalHeight,
-          width: horizontal ? totalHeight : '100%',
-          position: 'relative',
-          pointerEvents: 'none',
-        }}
-      >
-        {/* Visible items container */}
-        <div
-          className="virtual-scroll-content"
-          style={{
-            position: 'absolute',
-            top: 0,
-            left: 0,
-            height: '100%',
-            width: '100%',
-            pointerEvents: 'auto',
-          }}
-        >
-          {renderVisibleItems()}
-        </div>
-      </div>
-    </div>
-  );
-};
-
-// Grid virtual scrolling component for both rows and columns
-interface VirtualGridProps {
-  data: any[][];
-  rowHeight: number;
-  columnWidth: number | number[];
-  containerHeight: number;
-  containerWidth: number;
-  overscan?: number;
-  children: (item: any, rowIndex: number, colIndex: number, style: React.CSSProperties) => ReactNode;
-  onScroll?: (scrollLeft: number, scrollTop: number) => void;
-  className?: string;
-}
-
-export const VirtualGrid: React.FC<VirtualGridProps> = ({
-  data,
-  rowHeight,
-  columnWidth,
-  containerHeight,
-  containerWidth,
-  overscan = 3,
-  children,
-  onScroll,
-  className = '',
-}) => {
-  const containerRef = useRef<HTMLDivElement>(null);
-  const [scrollTop, setScrollTop] = useState(0);
-  const [scrollLeft, setScrollLeft] = useState(0);
-
-  const rowCount = data.length;
-  const colCount = data[0]?.length || 0;
-
-  // Calculate column positions for variable width columns
-  const columnWidths = Array.isArray(columnWidth) ? columnWidth : new Array(colCount).fill(columnWidth);
-  const columnPositions = columnWidths.reduce((acc, width, index) => {
-    acc[index] = index === 0 ? 0 : acc[index - 1] + columnWidths[index - 1];
-    return acc;
-  }, {} as Record<number, number>);
-
-  const totalWidth = columnWidths.reduce((sum, width) => sum + width, 0);
-  const totalHeight = rowCount * rowHeight;
-
-  // Calculate visible ranges
-  const startRowIndex = Math.max(0, Math.floor(scrollTop / rowHeight) - overscan);
-  const endRowIndex = Math.min(rowCount - 1, Math.ceil((scrollTop + containerHeight) / rowHeight) + overscan);
-
-  const startColIndex = Math.max(0, findColumnIndex(scrollLeft) - overscan);
-  const endColIndex = Math.min(colCount - 1, findColumnIndex(scrollLeft + containerWidth) + overscan);
-
-  function findColumnIndex(position: number): number {
-    for (let i = 0; i < colCount; i++) {
-      if (columnPositions[i] <= position && position < columnPositions[i] + columnWidths[i]) {
-        return i;
-      }
-    }
-    return colCount - 1;
-  }
-
-  const throttledScrollHandler = useThrottle(
-    useCallback((event: Event) => {
-      const target = event.target as HTMLDivElement;
-      const newScrollTop = target.scrollTop;
-      const newScrollLeft = target.scrollLeft;
-      
-      setScrollTop(newScrollTop);
-      setScrollLeft(newScrollLeft);
-      onScroll?.(newScrollLeft, newScrollTop);
-    }, [onScroll]),
-    16
-  );
-
-  useEffect(() => {
-    const container = containerRef.current;
-    if (!container) return;
-
-    container.addEventListener('scroll', throttledScrollHandler, { passive: true });
-    
-    return () => {
-      container.removeEventListener('scroll', throttledScrollHandler);
-    };
-  }, [throttledScrollHandler]);
-
-  const renderVisibleCells = () => {
-    const cells: ReactNode[] = [];
-
-    for (let rowIndex = startRowIndex; rowIndex <= endRowIndex; rowIndex++) {
-      for (let colIndex = startColIndex; colIndex <= endColIndex; colIndex++) {
-        const item = data[rowIndex]?.[colIndex];
-        if (!item) continue;
-
-        const cellStyle: React.CSSProperties = {
-          position: 'absolute',
-          top: rowIndex * rowHeight,
-          left: columnPositions[colIndex],
-          height: rowHeight,
-          width: columnWidths[colIndex],
-        };
-
-        cells.push(
-          <div key={`${rowIndex}-${colIndex}`} style={cellStyle}>
-            {children(item, rowIndex, colIndex, cellStyle)}
-          </div>
-        );
-      }
-    }
-
-    return cells;
-  };
-
-  return (
-    <div
-      ref={containerRef}
-      className={`virtual-grid overflow-auto ${className}`}
-      style={{
-        height: containerHeight,
-        width: containerWidth,
-        position: 'relative',
-      }}
-    >
-      <div
-        style={{
-          height: totalHeight,
-          width: totalWidth,
-          position: 'relative',
-        }}
-      >
-        {renderVisibleCells()}
-      </div>
-    </div>
-  );
-};
-
-// Timeline virtual scrolling component
-interface VirtualTimelineProps {
-  startDate: Date;
-  endDate: Date;
-  dayWidth: number;
-  containerWidth: number;
-  containerHeight: number;
-  overscan?: number;
-  children: (date: Date, index: number, style: React.CSSProperties) => ReactNode;
-  onScroll?: (scrollLeft: number) => void;
-  className?: string;
-}
-
-export const VirtualTimeline: React.FC<VirtualTimelineProps> = ({
-  startDate,
-  endDate,
-  dayWidth,
-  containerWidth,
-  containerHeight,
-  overscan = 10,
-  children,
-  onScroll,
-  className = '',
-}) => {
-  const containerRef = useRef<HTMLDivElement>(null);
-  const [scrollLeft, setScrollLeft] = useState(0);
-
-  const totalDays = Math.ceil((endDate.getTime() - startDate.getTime()) / (1000 * 60 * 60 * 24));
-  const totalWidth = totalDays * dayWidth;
-
-  const startDayIndex = Math.max(0, Math.floor(scrollLeft / dayWidth) - overscan);
-  const endDayIndex = Math.min(totalDays - 1, Math.ceil((scrollLeft + containerWidth) / dayWidth) + overscan);
-
-  const throttledScrollHandler = useThrottle(
-    useCallback((event: Event) => {
-      const target = event.target as HTMLDivElement;
-      const newScrollLeft = target.scrollLeft;
-      setScrollLeft(newScrollLeft);
-      onScroll?.(newScrollLeft);
-    }, [onScroll]),
-    16
-  );
-
-  useEffect(() => {
-    const container = containerRef.current;
-    if (!container) return;
-
-    container.addEventListener('scroll', throttledScrollHandler, { passive: true });
-    
-    return () => {
-      container.removeEventListener('scroll', throttledScrollHandler);
-    };
-  }, [throttledScrollHandler]);
-
-  const renderVisibleDays = () => {
-    const days: ReactNode[] = [];
-
-    for (let dayIndex = startDayIndex; dayIndex <= endDayIndex; dayIndex++) {
-      const date = new Date(startDate);
-      date.setDate(date.getDate() + dayIndex);
-
-      const dayStyle: React.CSSProperties = {
-        position: 'absolute',
-        left: dayIndex * dayWidth,
-        top: 0,
-        width: dayWidth,
-        height: '100%',
-      };
-
-      days.push(
-        <div key={dayIndex} style={dayStyle}>
-          {children(date, dayIndex, dayStyle)}
-        </div>
-      );
-    }
-
-    return days;
-  };
-
-  return (
-    <div
-      ref={containerRef}
-      className={`virtual-timeline overflow-x-auto ${className}`}
-      style={{
-        height: containerHeight,
-        width: containerWidth,
-        position: 'relative',
-      }}
-    >
-      <div
-        style={{
-          height: '100%',
-          width: totalWidth,
-          position: 'relative',
-        }}
-      >
-        {renderVisibleDays()}
-      </div>
-    </div>
-  );
-};
-
-export default VirtualScrollContainer;
--- a/worklenz-frontend/src/components/advanced-gantt/index.ts
+++ b/worklenz-frontend/src/components/advanced-gantt/index.ts
@@ -1,17 +0,0 @@
-// Main Components
-export { default as AdvancedGanttChart } from './AdvancedGanttChart';
-export { default as AdvancedGanttDemo } from './AdvancedGanttDemo';
-
-// Core Components
-export { default as GanttGrid } from './GanttGrid';
-export { default as DraggableTaskBar } from './DraggableTaskBar';
-export { default as TimelineMarkers, holidayPresets, workingDayPresets } from './TimelineMarkers';
-
-// Utility Components
-export { default as VirtualScrollContainer, VirtualGrid, VirtualTimeline } from './VirtualScrollContainer';
-
-// Types
-export * from '../../types/advanced-gantt.types';
-
-// Performance Utilities
-export * from '../../utils/gantt-performance';
--- a/worklenz-frontend/src/components/project-roadmap-gantt/PhaseModal.tsx
+++ b/worklenz-frontend/src/components/project-roadmap-gantt/PhaseModal.tsx
@@ -1,406 +0,0 @@
-import React, { useState } from 'react';
-import { 
-  Modal, 
-  Tabs, 
-  Progress, 
-  Tag, 
-  List, 
-  Avatar, 
-  Badge, 
-  Space, 
-  Button,
-  Statistic,
-  Row,
-  Col,
-  Timeline,
-  Input,
-  Form,
-  DatePicker,
-  Select
-} from 'antd';
-import { 
-  CalendarOutlined, 
-  TeamOutlined, 
-  CheckCircleOutlined, 
-  ClockCircleOutlined,
-  FlagOutlined,
-  ExclamationCircleOutlined,
-  EditOutlined,
-  SaveOutlined,
-  CloseOutlined
-} from '@ant-design/icons';
-import { PhaseModalData, ProjectPhase, PhaseTask, PhaseMilestone } from '../../types/project-roadmap.types';
-import { useAppSelector } from '../../hooks/useAppSelector';
-import { themeWiseColor } from '../../utils/themeWiseColor';
-import dayjs from 'dayjs';
-
-const { TabPane } = Tabs;
-const { TextArea } = Input;
-
-interface PhaseModalProps {
-  visible: boolean;
-  phase: PhaseModalData | null;
-  onClose: () => void;
-  onUpdate?: (updates: Partial<ProjectPhase>) => void;
-}
-
-const PhaseModal: React.FC<PhaseModalProps> = ({
-  visible,
-  phase,
-  onClose,
-  onUpdate,
-}) => {
-  const [isEditing, setIsEditing] = useState(false);
-  const [form] = Form.useForm();
-  
-  // Theme support
-  const themeMode = useAppSelector(state => state.themeReducer.mode);
-  const isDarkMode = themeMode === 'dark';
-
-  if (!phase) return null;
-
-  const handleEdit = () => {
-    setIsEditing(true);
-    form.setFieldsValue({
-      name: phase.name,
-      description: phase.description,
-      startDate: dayjs(phase.startDate),
-      endDate: dayjs(phase.endDate),
-      status: phase.status,
-    });
-  };
-
-  const handleSave = async () => {
-    try {
-      const values = await form.validateFields();
-      const updates: Partial<ProjectPhase> = {
-        name: values.name,
-        description: values.description,
-        startDate: values.startDate.toDate(),
-        endDate: values.endDate.toDate(),
-        status: values.status,
-      };
-      
-      onUpdate?.(updates);
-      setIsEditing(false);
-    } catch (error) {
-      console.error('Validation failed:', error);
-    }
-  };
-
-  const handleCancel = () => {
-    setIsEditing(false);
-    form.resetFields();
-  };
-
-  const getStatusColor = (status: string) => {
-    switch (status) {
-      case 'completed': return 'success';
-      case 'in-progress': return 'processing';
-      case 'on-hold': return 'warning';
-      default: return 'default';
-    }
-  };
-
-  const getPriorityColor = (priority: string) => {
-    switch (priority) {
-      case 'high': return 'red';
-      case 'medium': return 'orange';
-      case 'low': return 'green';
-      default: return 'default';
-    }
-  };
-
-  const getTaskStatusIcon = (status: string) => {
-    switch (status) {
-      case 'done': return <CheckCircleOutlined style={{ color: '#52c41a' }} />;
-      case 'in-progress': return <ClockCircleOutlined style={{ color: '#1890ff' }} />;
-      default: return <ExclamationCircleOutlined style={{ color: '#d9d9d9' }} />;
-    }
-  };
-
-  return (
-    <Modal
-      title={
-        <div className="flex justify-between items-center">
-          <Space>
-            <Badge status={getStatusColor(phase.status)} />
-            {isEditing ? (
-              <Form.Item name="name" className="mb-0">
-                <Input className="dark:bg-gray-700 dark:border-gray-600 dark:text-gray-100" />
-              </Form.Item>
-            ) : (
-              <h4 className="text-lg font-semibold text-gray-900 dark:text-gray-100 mb-0">
-                {phase.name}
-              </h4>
-            )}
-          </Space>
-          <Space>
-            {isEditing ? (
-              <>
-                <Button 
-                  type="primary" 
-                  icon={<SaveOutlined />} 
-                  onClick={handleSave}
-                  size="small"
-                >
-                  Save
-                </Button>
-                <Button 
-                  icon={<CloseOutlined />} 
-                  onClick={handleCancel}
-                  size="small"
-                  className="dark:border-gray-600 dark:text-gray-300"
-                >
-                  Cancel
-                </Button>
-              </>
-            ) : (
-              <Button 
-                type="text" 
-                icon={<EditOutlined />} 
-                onClick={handleEdit}
-                size="small"
-                className="dark:text-gray-300 dark:hover:bg-gray-700"
-              >
-                Edit
-              </Button>
-            )}
-          </Space>
-        </div>
-      }
-      open={visible}
-      onCancel={onClose}
-      width={800}
-      footer={null}
-      className="dark:bg-gray-800"
-    >
-      <Form form={form} layout="vertical">
-        <div className="mb-4">
-          {isEditing ? (
-            <Form.Item name="description" label={<span className="text-gray-700 dark:text-gray-300">Description</span>}>
-              <TextArea 
-                rows={2} 
-                className="dark:bg-gray-700 dark:border-gray-600 dark:text-gray-100" 
-              />
-            </Form.Item>
-          ) : (
-            <p className="text-gray-600 dark:text-gray-400">{phase.description}</p>
-          )}
-        </div>
-
-        {/* Phase Statistics */}
-        <Row gutter={16} className="mb-6">
-          <Col span={6}>
-            <div className="bg-gray-50 dark:bg-gray-700 border border-gray-200 dark:border-gray-600 rounded-lg p-4">
-              <Statistic 
-                title={<span className="text-gray-600 dark:text-gray-400">Progress</span>}
-                value={phase.progress} 
-                suffix="%" 
-                valueStyle={{ color: themeWiseColor('#1890ff', '#40a9ff', themeMode) }}
-              />
-              <Progress 
-                percent={phase.progress} 
-                showInfo={false} 
-                size="small" 
-                strokeColor={themeWiseColor('#1890ff', '#40a9ff', themeMode)}
-                trailColor={themeWiseColor('#f0f0f0', '#4b5563', themeMode)}
-              />
-            </div>
-          </Col>
-          <Col span={6}>
-            <div className="bg-gray-50 dark:bg-gray-700 border border-gray-200 dark:border-gray-600 rounded-lg p-4">
-              <Statistic 
-                title={<span className="text-gray-600 dark:text-gray-400">Tasks</span>}
-                value={phase.completedTaskCount} 
-                suffix={`/ ${phase.taskCount}`}
-                valueStyle={{ color: themeWiseColor('#52c41a', '#34d399', themeMode) }}
-              />
-            </div>
-          </Col>
-          <Col span={6}>
-            <div className="bg-gray-50 dark:bg-gray-700 border border-gray-200 dark:border-gray-600 rounded-lg p-4">
-              <Statistic 
-                title={<span className="text-gray-600 dark:text-gray-400">Milestones</span>}
-                value={phase.completedMilestoneCount} 
-                suffix={`/ ${phase.milestoneCount}`}
-                valueStyle={{ color: themeWiseColor('#722ed1', '#9f7aea', themeMode) }}
-              />
-            </div>
-          </Col>
-          <Col span={6}>
-            <div className="bg-gray-50 dark:bg-gray-700 border border-gray-200 dark:border-gray-600 rounded-lg p-4">
-              <Statistic 
-                title={<span className="text-gray-600 dark:text-gray-400">Team</span>}
-                value={phase.teamMembers.length} 
-                suffix="members"
-                valueStyle={{ color: themeWiseColor('#fa8c16', '#fbbf24', themeMode) }}
-              />
-            </div>
-          </Col>
-        </Row>
-
-        {/* Timeline */}
-        <Row gutter={16} className="mb-6">
-          <Col span={12}>
-            {isEditing ? (
-              <Form.Item name="startDate" label={<span className="text-gray-700 dark:text-gray-300">Start Date</span>}>
-                <DatePicker className="w-full dark:bg-gray-700 dark:border-gray-600" />
-              </Form.Item>
-            ) : (
-              <div className="bg-gray-50 dark:bg-gray-700 border border-gray-200 dark:border-gray-600 rounded-lg p-4">
-                <div className="flex items-center gap-2">
-                  <CalendarOutlined className="text-gray-600 dark:text-gray-400" />
-                  <span className="font-medium text-gray-900 dark:text-gray-100">Start:</span>
-                  <span className="text-gray-600 dark:text-gray-400">{phase.startDate.toLocaleDateString()}</span>
-                </div>
-              </div>
-            )}
-          </Col>
-          <Col span={12}>
-            {isEditing ? (
-              <Form.Item name="endDate" label={<span className="text-gray-700 dark:text-gray-300">End Date</span>}>
-                <DatePicker className="w-full dark:bg-gray-700 dark:border-gray-600" />
-              </Form.Item>
-            ) : (
-              <div className="bg-gray-50 dark:bg-gray-700 border border-gray-200 dark:border-gray-600 rounded-lg p-4">
-                <div className="flex items-center gap-2">
-                  <CalendarOutlined className="text-gray-600 dark:text-gray-400" />
-                  <span className="font-medium text-gray-900 dark:text-gray-100">End:</span>
-                  <span className="text-gray-600 dark:text-gray-400">{phase.endDate.toLocaleDateString()}</span>
-                </div>
-              </div>
-            )}
-          </Col>
-        </Row>
-
-        {isEditing && (
-          <Row gutter={16} className="mb-6">
-            <Col span={12}>
-              <Form.Item name="status" label={<span className="text-gray-700 dark:text-gray-300">Status</span>}>
-                <Select className="dark:bg-gray-700 dark:border-gray-600">
-                  <Select.Option value="not-started">Not Started</Select.Option>
-                  <Select.Option value="in-progress">In Progress</Select.Option>
-                  <Select.Option value="completed">Completed</Select.Option>
-                  <Select.Option value="on-hold">On Hold</Select.Option>
-                </Select>
-              </Form.Item>
-            </Col>
-          </Row>
-        )}
-
-        <Tabs 
-          defaultActiveKey="tasks"
-          className="dark:bg-gray-800"
-          tabBarStyle={{ 
-            borderBottom: `1px solid ${themeWiseColor('#f0f0f0', '#4b5563', themeMode)}`
-          }}
-        >
-          <TabPane tab={`Tasks (${phase.taskCount})`} key="tasks">
-            <List
-              dataSource={phase.tasks}
-              renderItem={(task: PhaseTask) => (
-                <List.Item>
-                  <List.Item.Meta
-                    avatar={getTaskStatusIcon(task.status)}
-                    title={
-                      <div className="flex justify-between items-center">
-                        <Text strong>{task.name}</Text>
-                        <Space>
-                          <Tag color={getPriorityColor(task.priority)}>
-                            {task.priority}
-                          </Tag>
-                          <Progress 
-                            percent={task.progress} 
-                            size="small" 
-                            style={{ width: 100 }}
-                          />
-                        </Space>
-                      </div>
-                    }
-                    description={
-                      <div>
-                        <Text type="secondary">{task.description}</Text>
-                        <div className="mt-2 flex justify-between items-center">
-                          <Space>
-                            <CalendarOutlined />
-                            <Text type="secondary">
-                              {task.startDate.toLocaleDateString()} - {task.endDate.toLocaleDateString()}
-                            </Text>
-                          </Space>
-                          {task.assigneeName && (
-                            <Space>
-                              <TeamOutlined />
-                              <Text type="secondary">{task.assigneeName}</Text>
-                            </Space>
-                          )}
-                        </div>
-                      </div>
-                    }
-                  />
-                </List.Item>
-              )}
-            />
-          </TabPane>
-
-          <TabPane tab={`Milestones (${phase.milestoneCount})`} key="milestones">
-            <Timeline>
-              {phase.milestones.map((milestone: PhaseMilestone) => (
-                <Timeline.Item
-                  key={milestone.id}
-                  color={milestone.isCompleted ? 'green' : milestone.criticalPath ? 'red' : 'blue'}
-                  dot={milestone.isCompleted ? <CheckCircleOutlined /> : <FlagOutlined />}
-                >
-                  <div className="flex justify-between items-start">
-                    <div>
-                      <Text strong>{milestone.name}</Text>
-                      {milestone.criticalPath && (
-                        <Tag color="red" className="ml-2">Critical Path</Tag>
-                      )}
-                      {milestone.description && (
-                        <div className="mt-1">
-                          <Text type="secondary">{milestone.description}</Text>
-                        </div>
-                      )}
-                    </div>
-                    <div className="text-right">
-                      <div>
-                        <CalendarOutlined />
-                        <span className="ml-1">{milestone.dueDate.toLocaleDateString()}</span>
-                      </div>
-                      <Badge 
-                        status={milestone.isCompleted ? 'success' : 'processing'} 
-                        text={milestone.isCompleted ? 'Completed' : 'Pending'}
-                      />
-                    </div>
-                  </div>
-                </Timeline.Item>
-              ))}
-            </Timeline>
-          </TabPane>
-
-          <TabPane tab={`Team (${phase.teamMembers.length})`} key="team">
-            <List
-              dataSource={phase.teamMembers}
-              renderItem={(member: string) => (
-                <List.Item>
-                  <List.Item.Meta
-                    avatar={<Avatar>{member.charAt(0).toUpperCase()}</Avatar>}
-                    title={member}
-                    description={
-                      <Text type="secondary">
-                        {phase.tasks.filter(task => task.assigneeName === member).length} tasks assigned
-                      </Text>
-                    }
-                  />
-                </List.Item>
-              )}
-            />
-          </TabPane>
-        </Tabs>
-      </Form>
-    </Modal>
-  );
-};
-
-export default PhaseModal;
--- a/worklenz-frontend/src/components/project-roadmap-gantt/ProjectRoadmapGantt.tsx
+++ b/worklenz-frontend/src/components/project-roadmap-gantt/ProjectRoadmapGantt.tsx
@@ -1,333 +0,0 @@
-import React, { useState, useMemo } from 'react';
-import { Gantt, Task, ViewMode } from 'gantt-task-react';
-import { Button, Space, Badge } from 'antd';
-import { CalendarOutlined, TeamOutlined, CheckCircleOutlined } from '@ant-design/icons';
-import { ProjectPhase, ProjectRoadmap, GanttViewOptions, PhaseModalData } from '../../types/project-roadmap.types';
-import PhaseModal from './PhaseModal';
-import { useAppSelector } from '../../hooks/useAppSelector';
-import { themeWiseColor } from '../../utils/themeWiseColor';
-import 'gantt-task-react/dist/index.css';
-import './gantt-theme.css';
-
-interface ProjectRoadmapGanttProps {
-  roadmap: ProjectRoadmap;
-  viewOptions?: Partial<GanttViewOptions>;
-  onPhaseUpdate?: (phaseId: string, updates: Partial<ProjectPhase>) => void;
-  onTaskUpdate?: (phaseId: string, taskId: string, updates: any) => void;
-}
-
-const ProjectRoadmapGantt: React.FC<ProjectRoadmapGanttProps> = ({
-  roadmap,
-  viewOptions = {},
-  onPhaseUpdate,
-  onTaskUpdate,
-}) => {
-  const [selectedPhase, setSelectedPhase] = useState<PhaseModalData | null>(null);
-  const [isModalVisible, setIsModalVisible] = useState(false);
-  const [viewMode, setViewMode] = useState<ViewMode>(ViewMode.Month);
-  
-  // Theme support
-  const themeMode = useAppSelector(state => state.themeReducer.mode);
-  const isDarkMode = themeMode === 'dark';
-
-  const defaultViewOptions: GanttViewOptions = {
-    viewMode: 'month',
-    showTasks: true,
-    showMilestones: true,
-    groupByPhase: true,
-    ...viewOptions,
-  };
-
-  // Theme-aware colors
-  const ganttColors = useMemo(() => {
-    return {
-      background: themeWiseColor('#ffffff', '#1f2937', themeMode),
-      surface: themeWiseColor('#f8f9fa', '#374151', themeMode),
-      border: themeWiseColor('#e5e7eb', '#4b5563', themeMode),
-      taskBar: themeWiseColor('#3b82f6', '#60a5fa', themeMode),
-      taskBarHover: themeWiseColor('#2563eb', '#93c5fd', themeMode),
-      progressBar: themeWiseColor('#10b981', '#34d399', themeMode),
-      milestone: themeWiseColor('#f59e0b', '#fbbf24', themeMode),
-      criticalPath: themeWiseColor('#ef4444', '#f87171', themeMode),
-      text: {
-        primary: themeWiseColor('#111827', '#f9fafb', themeMode),
-        secondary: themeWiseColor('#6b7280', '#d1d5db', themeMode),
-      },
-      grid: themeWiseColor('#f3f4f6', '#4b5563', themeMode),
-      today: themeWiseColor('rgba(59, 130, 246, 0.1)', 'rgba(96, 165, 250, 0.2)', themeMode),
-    };
-  }, [themeMode]);
-
-  // Convert phases to Gantt tasks
-  const ganttTasks = useMemo(() => {
-    const tasks: Task[] = [];
-
-    roadmap.phases.forEach((phase, phaseIndex) => {
-      // Add phase as main task with theme-aware colors
-      const phaseTask: Task = {
-        id: phase.id,
-        name: phase.name,
-        start: phase.startDate,
-        end: phase.endDate,
-        progress: phase.progress,
-        type: 'project',
-        styles: {
-          progressColor: themeWiseColor(phase.color, phase.color, themeMode),
-          progressSelectedColor: themeWiseColor(phase.color, phase.color, themeMode),
-          backgroundColor: themeWiseColor(`${phase.color}20`, `${phase.color}30`, themeMode),
-        },
-      };
-      tasks.push(phaseTask);
-
-      // Add phase tasks if enabled
-      if (defaultViewOptions.showTasks) {
-        phase.tasks.forEach((task) => {
-          const ganttTask: Task = {
-            id: task.id,
-            name: task.name,
-            start: task.startDate,
-            end: task.endDate,
-            progress: task.progress,
-            type: 'task',
-            project: phase.id,
-            dependencies: task.dependencies,
-            styles: {
-              progressColor: ganttColors.taskBar,
-              progressSelectedColor: ganttColors.taskBarHover,
-              backgroundColor: themeWiseColor('rgba(59, 130, 246, 0.1)', 'rgba(96, 165, 250, 0.2)', themeMode),
-            },
-          };
-          tasks.push(ganttTask);
-        });
-      }
-
-      // Add milestones if enabled
-      if (defaultViewOptions.showMilestones) {
-        phase.milestones.forEach((milestone) => {
-          const milestoneTask: Task = {
-            id: milestone.id,
-            name: milestone.name,
-            start: milestone.dueDate,
-            end: milestone.dueDate,
-            progress: milestone.isCompleted ? 100 : 0,
-            type: 'milestone',
-            project: phase.id,
-            styles: {
-              progressColor: milestone.criticalPath ? ganttColors.criticalPath : ganttColors.progressBar,
-              progressSelectedColor: milestone.criticalPath ? ganttColors.criticalPath : ganttColors.progressBar,
-              backgroundColor: milestone.criticalPath ? 
-                themeWiseColor('rgba(239, 68, 68, 0.1)', 'rgba(248, 113, 113, 0.2)', themeMode) :
-                themeWiseColor('rgba(16, 185, 129, 0.1)', 'rgba(52, 211, 153, 0.2)', themeMode),
-            },
-          };
-          tasks.push(milestoneTask);
-        });
-      }
-    });
-
-    return tasks;
-  }, [roadmap.phases, defaultViewOptions, ganttColors, themeMode]);
-
-  const handlePhaseClick = (phase: ProjectPhase) => {
-    const taskCount = phase.tasks.length;
-    const completedTaskCount = phase.tasks.filter(task => task.status === 'done').length;
-    const milestoneCount = phase.milestones.length;
-    const completedMilestoneCount = phase.milestones.filter(m => m.isCompleted).length;
-    const teamMembers = [...new Set(phase.tasks.map(task => task.assigneeName).filter(Boolean))];
-
-    const phaseModalData: PhaseModalData = {
-      ...phase,
-      taskCount,
-      completedTaskCount,
-      milestoneCount,
-      completedMilestoneCount,
-      teamMembers,
-    };
-
-    setSelectedPhase(phaseModalData);
-    setIsModalVisible(true);
-  };
-
-  const handleTaskClick = (task: Task) => {
-    // Find the phase this task belongs to
-    const phase = roadmap.phases.find(p => 
-      p.tasks.some(t => t.id === task.id) || p.milestones.some(m => m.id === task.id)
-    );
-    
-    if (phase) {
-      handlePhaseClick(phase);
-    }
-  };
-
-  const handleDateChange = (task: Task) => {
-    const phase = roadmap.phases.find(p => p.id === task.id);
-    if (phase && onPhaseUpdate) {
-      onPhaseUpdate(phase.id, {
-        startDate: task.start,
-        endDate: task.end,
-      });
-    } else if (onTaskUpdate) {
-      const parentPhase = roadmap.phases.find(p => 
-        p.tasks.some(t => t.id === task.id)
-      );
-      if (parentPhase) {
-        onTaskUpdate(parentPhase.id, task.id, {
-          startDate: task.start,
-          endDate: task.end,
-        });
-      }
-    }
-  };
-
-  const handleProgressChange = (task: Task) => {
-    const phase = roadmap.phases.find(p => p.id === task.id);
-    if (phase && onPhaseUpdate) {
-      onPhaseUpdate(phase.id, { progress: task.progress });
-    } else if (onTaskUpdate) {
-      const parentPhase = roadmap.phases.find(p => 
-        p.tasks.some(t => t.id === task.id)
-      );
-      if (parentPhase) {
-        onTaskUpdate(parentPhase.id, task.id, { progress: task.progress });
-      }
-    }
-  };
-
-  const getStatusColor = (status: string) => {
-    switch (status) {
-      case 'completed': return '#52c41a';
-      case 'in-progress': return '#1890ff';
-      case 'on-hold': return '#faad14';
-      default: return '#d9d9d9';
-    }
-  };
-
-  const columnWidth = viewMode === ViewMode.Year ? 350 : 
-                    viewMode === ViewMode.Month ? 300 : 
-                    viewMode === ViewMode.Week ? 250 : 60;
-
-  return (
-    <div className="project-roadmap-gantt w-full">
-      {/* Header */}
-      <div className="bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded-lg shadow-sm mb-4">
-        <div className="p-6">
-          <div className="flex justify-between items-center mb-4">
-            <div>
-              <h3 className="text-xl font-semibold text-gray-900 dark:text-gray-100 mb-2">
-                {roadmap.name}
-              </h3>
-              {roadmap.description && (
-                <p className="text-gray-600 dark:text-gray-400 mb-0">
-                  {roadmap.description}
-                </p>
-              )}
-            </div>
-            <Space>
-              <Button 
-                type={viewMode === ViewMode.Week ? 'primary' : 'default'}
-                onClick={() => setViewMode(ViewMode.Week)}
-                className="dark:border-gray-600 dark:text-gray-300"
-              >
-                Week
-              </Button>
-              <Button 
-                type={viewMode === ViewMode.Month ? 'primary' : 'default'}
-                onClick={() => setViewMode(ViewMode.Month)}
-                className="dark:border-gray-600 dark:text-gray-300"
-              >
-                Month
-              </Button>
-              <Button 
-                type={viewMode === ViewMode.Year ? 'primary' : 'default'}
-                onClick={() => setViewMode(ViewMode.Year)}
-                className="dark:border-gray-600 dark:text-gray-300"
-              >
-                Year
-              </Button>
-            </Space>
-          </div>
-
-          {/* Phase Overview */}
-          <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 gap-4 mb-4">
-            {roadmap.phases.map((phase) => (
-              <div 
-                key={phase.id}
-                className="bg-gray-50 dark:bg-gray-700 border border-gray-200 dark:border-gray-600 rounded-lg p-4 cursor-pointer hover:shadow-md hover:bg-gray-100 dark:hover:bg-gray-600 transition-all duration-200"
-                onClick={() => handlePhaseClick(phase)}
-              >
-                <div className="flex items-center justify-between mb-3">
-                  <Badge 
-                    color={getStatusColor(phase.status)} 
-                    text={
-                      <span className="font-medium text-gray-900 dark:text-gray-100">
-                        {phase.name}
-                      </span>
-                    }
-                  />
-                </div>
-                <div className="space-y-2 text-sm">
-                  <div className="flex items-center gap-2 text-gray-600 dark:text-gray-400">
-                    <CalendarOutlined className="w-4 h-4" />
-                    <span>{phase.startDate.toLocaleDateString()} - {phase.endDate.toLocaleDateString()}</span>
-                  </div>
-                  <div className="flex items-center gap-2 text-gray-600 dark:text-gray-400">
-                    <TeamOutlined className="w-4 h-4" />
-                    <span>{phase.tasks.length} tasks</span>
-                  </div>
-                  <div className="flex items-center gap-2 text-gray-600 dark:text-gray-400">
-                    <CheckCircleOutlined className="w-4 h-4" />
-                    <span>{phase.progress}% complete</span>
-                  </div>
-                </div>
-              </div>
-            ))}
-          </div>
-        </div>
-      </div>
-
-      {/* Gantt Chart */}
-      <div className="bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded-lg shadow-sm">
-        <div className="p-4">
-          <div className="w-full overflow-x-auto">
-            <div 
-              className="gantt-container"
-              style={{ 
-                '--gantt-background': ganttColors.background,
-                '--gantt-grid': ganttColors.grid,
-                '--gantt-text': ganttColors.text.primary,
-                '--gantt-border': ganttColors.border,
-              } as React.CSSProperties}
-            >
-              <Gantt
-                tasks={ganttTasks}
-                viewMode={viewMode}
-                onDateChange={handleDateChange}
-                onProgressChange={handleProgressChange}
-                onDoubleClick={handleTaskClick}
-                listCellWidth=""
-                columnWidth={columnWidth}
-                todayColor={ganttColors.today}
-                projectProgressColor={ganttColors.progressBar}
-                projectBackgroundColor={themeWiseColor('rgba(82, 196, 26, 0.1)', 'rgba(52, 211, 153, 0.2)', themeMode)}
-              />
-            </div>
-          </div>
-        </div>
-      </div>
-
-      {/* Phase Modal */}
-      <PhaseModal
-        visible={isModalVisible}
-        phase={selectedPhase}
-        onClose={() => setIsModalVisible(false)}
-        onUpdate={(updates) => {
-          if (selectedPhase && onPhaseUpdate) {
-            onPhaseUpdate(selectedPhase.id, updates);
-          }
-        }}
-      />
-    </div>
-  );
-};
-
-export default ProjectRoadmapGantt;
--- a/worklenz-frontend/src/components/project-roadmap-gantt/RoadmapDemo.tsx
+++ b/worklenz-frontend/src/components/project-roadmap-gantt/RoadmapDemo.tsx
@@ -1,112 +0,0 @@
-import React, { useState } from 'react';
-import { Button, Space, message } from 'antd';
-import ProjectRoadmapGantt from './ProjectRoadmapGantt';
-import { sampleProjectRoadmap } from './sample-data';
-import { ProjectPhase, ProjectRoadmap } from '../../types/project-roadmap.types';
-import { useAppSelector } from '../../hooks/useAppSelector';
-
-const RoadmapDemo: React.FC = () => {
-  const [roadmap, setRoadmap] = useState<ProjectRoadmap>(sampleProjectRoadmap);
-  const themeMode = useAppSelector(state => state.themeReducer.mode);
-
-  const handlePhaseUpdate = (phaseId: string, updates: Partial<ProjectPhase>) => {
-    setRoadmap(prevRoadmap => ({
-      ...prevRoadmap,
-      phases: prevRoadmap.phases.map(phase => 
-        phase.id === phaseId 
-          ? { ...phase, ...updates }
-          : phase
-      )
-    }));
-    
-    message.success('Phase updated successfully!');
-  };
-
-  const handleTaskUpdate = (phaseId: string, taskId: string, updates: any) => {
-    setRoadmap(prevRoadmap => ({
-      ...prevRoadmap,
-      phases: prevRoadmap.phases.map(phase => 
-        phase.id === phaseId 
-          ? {
-              ...phase,
-              tasks: phase.tasks.map(task => 
-                task.id === taskId 
-                  ? { ...task, ...updates }
-                  : task
-              )
-            }
-          : phase
-      )
-    }));
-    
-    message.success('Task updated successfully!');
-  };
-
-  const resetToSampleData = () => {
-    setRoadmap(sampleProjectRoadmap);
-    message.info('Roadmap reset to sample data');
-  };
-
-  return (
-    <div className="roadmap-demo p-6 bg-gray-50 dark:bg-gray-900 min-h-screen">
-      <div className="bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded-lg shadow-sm mb-4">
-        <div className="p-6">
-          <div className="flex justify-between items-center">
-            <div>
-              <h2 className="text-2xl font-bold text-gray-900 dark:text-gray-100 mb-2">
-                Project Roadmap Gantt Chart Demo
-              </h2>
-              <p className="text-gray-600 dark:text-gray-400 mb-0">
-                Interactive Gantt chart showing project phases as milestones/epics. 
-                Click on any phase card or Gantt bar to view detailed information in a modal.
-              </p>
-            </div>
-            <Space>
-              <Button 
-                onClick={resetToSampleData}
-                className="dark:border-gray-600 dark:text-gray-300 dark:hover:bg-gray-700"
-              >
-                Reset to Sample Data
-              </Button>
-            </Space>
-          </div>
-        </div>
-      </div>
-
-      <ProjectRoadmapGantt
-        roadmap={roadmap}
-        viewOptions={{
-          viewMode: 'month',
-          showTasks: true,
-          showMilestones: true,
-          groupByPhase: true,
-        }}
-        onPhaseUpdate={handlePhaseUpdate}
-        onTaskUpdate={handleTaskUpdate}
-      />
-
-      <div className="bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded-lg shadow-sm mt-4">
-        <div className="p-6">
-          <h3 className="text-lg font-semibold text-gray-900 dark:text-gray-100 mb-3">
-            Features Demonstrated:
-          </h3>
-          <ul className="space-y-2 text-gray-700 dark:text-gray-300">
-            <li>• <strong className="text-gray-900 dark:text-gray-100">Phase-based Grouping:</strong> Projects organized by phases (Planning, Development, Testing, Deployment)</li>
-            <li>• <strong className="text-gray-900 dark:text-gray-100">Interactive Phase Cards:</strong> Click on phase cards for detailed view</li>
-            <li>• <strong className="text-gray-900 dark:text-gray-100">Gantt Chart Visualization:</strong> Timeline view with tasks, milestones, and dependencies</li>
-            <li>• <strong className="text-gray-900 dark:text-gray-100">Modal Details:</strong> Comprehensive phase information with tasks, milestones, and team members</li>
-            <li>• <strong className="text-gray-900 dark:text-gray-100">Progress Tracking:</strong> Visual progress indicators and completion statistics</li>
-            <li>• <strong className="text-gray-900 dark:text-gray-100">Multiple View Modes:</strong> Week, Month, and Year timeline views</li>
-            <li>• <strong className="text-gray-900 dark:text-gray-100">Task Management:</strong> Task assignments, priorities, and status tracking</li>
-            <li>• <strong className="text-gray-900 dark:text-gray-100">Milestone Tracking:</strong> Critical path milestones and completion status</li>
-            <li>• <strong className="text-gray-900 dark:text-gray-100">Team Overview:</strong> Team member assignments and workload distribution</li>
-            <li>• <strong className="text-gray-900 dark:text-gray-100">Editable Fields:</strong> In-modal editing for phase attributes (name, description, dates, status)</li>
-            <li>• <strong className="text-gray-900 dark:text-gray-100">Theme Support:</strong> Automatic light/dark theme adaptation with consistent styling</li>
-          </ul>
-        </div>
-      </div>
-    </div>
-  );
-};
-
-export default RoadmapDemo;
--- a/worklenz-frontend/src/components/project-roadmap-gantt/gantt-theme.css
+++ b/worklenz-frontend/src/components/project-roadmap-gantt/gantt-theme.css
@@ -1,221 +0,0 @@
-/* Custom Gantt Chart Theme Overrides */
-
-/* Light theme styles */
-.gantt-container {
-  font-family: inherit;
-}
-
-.gantt-container .gantt-header {
-  background-color: var(--gantt-background, #ffffff);
-  border-bottom: 1px solid var(--gantt-border, #e5e7eb);
-  color: var(--gantt-text, #111827);
-}
-
-.gantt-container .gantt-task-list-wrapper {
-  background-color: var(--gantt-background, #ffffff);
-  border-right: 1px solid var(--gantt-border, #e5e7eb);
-}
-
-.gantt-container .gantt-task-list-table {
-  background-color: var(--gantt-background, #ffffff);
-}
-
-.gantt-container .gantt-task-list-table-row {
-  color: var(--gantt-text, #111827);
-  border-bottom: 1px solid var(--gantt-grid, #f3f4f6);
-}
-
-.gantt-container .gantt-task-list-table-row:hover {
-  background-color: var(--gantt-grid, #f3f4f6);
-}
-
-.gantt-container .gantt-gantt {
-  background-color: var(--gantt-background, #ffffff);
-}
-
-.gantt-container .gantt-vertical-container {
-  background-color: var(--gantt-background, #ffffff);
-}
-
-.gantt-container .gantt-horizontal-container {
-  background-color: var(--gantt-background, #ffffff);
-}
-
-.gantt-container .gantt-calendar {
-  background-color: var(--gantt-background, #ffffff);
-  border-bottom: 1px solid var(--gantt-border, #e5e7eb);
-}
-
-.gantt-container .gantt-calendar-row {
-  color: var(--gantt-text, #111827);
-  background-color: var(--gantt-background, #ffffff);
-  border-bottom: 1px solid var(--gantt-grid, #f3f4f6);
-}
-
-.gantt-container .gantt-grid-body {
-  background-color: var(--gantt-background, #ffffff);
-}
-
-.gantt-container .gantt-grid-row {
-  border-bottom: 1px solid var(--gantt-grid, #f3f4f6);
-}
-
-.gantt-container .gantt-grid-row-line {
-  border-left: 1px solid var(--gantt-grid, #f3f4f6);
-}
-
-/* Dark theme overrides */
-html.dark .gantt-container .gantt-header {
-  background-color: #1f2937;
-  border-bottom-color: #4b5563;
-  color: #f9fafb;
-}
-
-html.dark .gantt-container .gantt-task-list-wrapper {
-  background-color: #1f2937;
-  border-right-color: #4b5563;
-}
-
-html.dark .gantt-container .gantt-task-list-table {
-  background-color: #1f2937;
-}
-
-html.dark .gantt-container .gantt-task-list-table-row {
-  color: #f9fafb;
-  border-bottom-color: #4b5563;
-}
-
-html.dark .gantt-container .gantt-task-list-table-row:hover {
-  background-color: #374151;
-}
-
-html.dark .gantt-container .gantt-gantt {
-  background-color: #1f2937;
-}
-
-html.dark .gantt-container .gantt-vertical-container {
-  background-color: #1f2937;
-}
-
-html.dark .gantt-container .gantt-horizontal-container {
-  background-color: #1f2937;
-}
-
-html.dark .gantt-container .gantt-calendar {
-  background-color: #1f2937;
-  border-bottom-color: #4b5563;
-}
-
-html.dark .gantt-container .gantt-calendar-row {
-  color: #f9fafb;
-  background-color: #1f2937;
-  border-bottom-color: #4b5563;
-}
-
-html.dark .gantt-container .gantt-grid-body {
-  background-color: #1f2937;
-}
-
-html.dark .gantt-container .gantt-grid-row {
-  border-bottom-color: #4b5563;
-}
-
-html.dark .gantt-container .gantt-grid-row-line {
-  border-left-color: #4b5563;
-}
-
-/* Tooltip theming */
-.gantt-container .gantt-tooltip {
-  background-color: var(--gantt-background, #ffffff);
-  border: 1px solid var(--gantt-border, #e5e7eb);
-  color: var(--gantt-text, #111827);
-  box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
-}
-
-html.dark .gantt-container .gantt-tooltip {
-  background-color: #374151;
-  border-color: #4b5563;
-  color: #f9fafb;
-  box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.3);
-}
-
-/* Task bar styling improvements */
-.gantt-container .gantt-task-progress {
-  border-radius: 2px;
-}
-
-.gantt-container .gantt-task-background {
-  border-radius: 4px;
-  border: 1px solid var(--gantt-border, #e5e7eb);
-}
-
-html.dark .gantt-container .gantt-task-background {
-  border-color: #4b5563;
-}
-
-/* Milestone styling */
-.gantt-container .gantt-milestone {
-  filter: drop-shadow(0 1px 2px rgba(0, 0, 0, 0.1));
-}
-
-html.dark .gantt-container .gantt-milestone {
-  filter: drop-shadow(0 1px 2px rgba(0, 0, 0, 0.3));
-}
-
-/* Selection and hover states */
-.gantt-container .gantt-task:hover .gantt-task-background {
-  opacity: 0.9;
-  transform: translateY(-1px);
-  transition: all 0.2s ease;
-}
-
-.gantt-container .gantt-task-selected .gantt-task-background {
-  box-shadow: 0 0 0 2px rgba(59, 130, 246, 0.3);
-}
-
-html.dark .gantt-container .gantt-task-selected .gantt-task-background {
-  box-shadow: 0 0 0 2px rgba(96, 165, 250, 0.3);
-}
-
-/* Responsive improvements */
-@media (max-width: 768px) {
-  .gantt-container {
-    font-size: 14px;
-  }
-  
-  .gantt-container .gantt-task-list-wrapper {
-    min-width: 200px;
-  }
-}
-
-/* Scrollbar theming */
-.gantt-container ::-webkit-scrollbar {
-  width: 8px;
-  height: 8px;
-}
-
-.gantt-container ::-webkit-scrollbar-track {
-  background: var(--gantt-grid, #f3f4f6);
-  border-radius: 4px;
-}
-
-.gantt-container ::-webkit-scrollbar-thumb {
-  background: var(--gantt-border, #e5e7eb);
-  border-radius: 4px;
-}
-
-.gantt-container ::-webkit-scrollbar-thumb:hover {
-  background: #9ca3af;
-}
-
-html.dark .gantt-container ::-webkit-scrollbar-track {
-  background: #4b5563;
-}
-
-html.dark .gantt-container ::-webkit-scrollbar-thumb {
-  background: #6b7280;
-}
-
-html.dark .gantt-container ::-webkit-scrollbar-thumb:hover {
-  background: #9ca3af;
-}
--- a/worklenz-frontend/src/components/project-roadmap-gantt/index.ts
+++ b/worklenz-frontend/src/components/project-roadmap-gantt/index.ts
@@ -1,5 +0,0 @@
-export { default as ProjectRoadmapGantt } from './ProjectRoadmapGantt';
-export { default as PhaseModal } from './PhaseModal';
-export { default as RoadmapDemo } from './RoadmapDemo';
-export { sampleProjectRoadmap } from './sample-data';
-export * from '../../types/project-roadmap.types';
--- a/worklenz-frontend/src/components/project-roadmap-gantt/sample-data.ts
+++ b/worklenz-frontend/src/components/project-roadmap-gantt/sample-data.ts
@@ -1,317 +0,0 @@
-import { ProjectRoadmap, ProjectPhase, PhaseTask, PhaseMilestone } from '../../types/project-roadmap.types';
-
-// Sample tasks for Planning Phase
-const planningTasks: PhaseTask[] = [
-  {
-    id: 'task-planning-1',
-    name: 'Project Requirements Analysis',
-    description: 'Gather and analyze project requirements from stakeholders',
-    startDate: new Date(2024, 11, 1), // December 1, 2024
-    endDate: new Date(2024, 11, 5),
-    progress: 100,
-    assigneeId: 'user-1',
-    assigneeName: 'Alice Johnson',
-    priority: 'high',
-    status: 'done',
-  },
-  {
-    id: 'task-planning-2',
-    name: 'Technical Architecture Design',
-    description: 'Design the technical architecture and system components',
-    startDate: new Date(2024, 11, 6),
-    endDate: new Date(2024, 11, 12),
-    progress: 75,
-    assigneeId: 'user-2',
-    assigneeName: 'Bob Smith',
-    priority: 'high',
-    status: 'in-progress',
-  },
-  {
-    id: 'task-planning-3',
-    name: 'Resource Allocation Planning',
-    description: 'Plan and allocate team resources for the project',
-    startDate: new Date(2024, 11, 8),
-    endDate: new Date(2024, 11, 15),
-    progress: 50,
-    assigneeId: 'user-3',
-    assigneeName: 'Carol Davis',
-    priority: 'medium',
-    status: 'in-progress',
-    dependencies: ['task-planning-1'],
-  }
-];
-
-// Sample milestones for Planning Phase
-const planningMilestones: PhaseMilestone[] = [
-  {
-    id: 'milestone-planning-1',
-    name: 'Requirements Approved',
-    description: 'All project requirements have been reviewed and approved by stakeholders',
-    dueDate: new Date(2024, 11, 5),
-    isCompleted: true,
-    criticalPath: true,
-  },
-  {
-    id: 'milestone-planning-2',
-    name: 'Architecture Review Complete',
-    description: 'Technical architecture has been reviewed and approved',
-    dueDate: new Date(2024, 11, 15),
-    isCompleted: false,
-    criticalPath: true,
-  }
-];
-
-// Sample tasks for Development Phase
-const developmentTasks: PhaseTask[] = [
-  {
-    id: 'task-dev-1',
-    name: 'Frontend Component Development',
-    description: 'Develop core frontend components using React',
-    startDate: new Date(2024, 11, 16),
-    endDate: new Date(2025, 0, 31), // January 31, 2025
-    progress: 30,
-    assigneeId: 'user-4',
-    assigneeName: 'David Wilson',
-    priority: 'high',
-    status: 'in-progress',
-    dependencies: ['task-planning-2'],
-  },
-  {
-    id: 'task-dev-2',
-    name: 'Backend API Development',
-    description: 'Develop REST APIs and database models',
-    startDate: new Date(2024, 11, 16),
-    endDate: new Date(2025, 0, 25),
-    progress: 45,
-    assigneeId: 'user-5',
-    assigneeName: 'Eva Brown',
-    priority: 'high',
-    status: 'in-progress',
-    dependencies: ['task-planning-2'],
-  },
-  {
-    id: 'task-dev-3',
-    name: 'Database Setup and Migration',
-    description: 'Set up production database and create migration scripts',
-    startDate: new Date(2024, 11, 20),
-    endDate: new Date(2025, 0, 15),
-    progress: 80,
-    assigneeId: 'user-6',
-    assigneeName: 'Frank Miller',
-    priority: 'medium',
-    status: 'in-progress',
-  }
-];
-
-// Sample milestones for Development Phase
-const developmentMilestones: PhaseMilestone[] = [
-  {
-    id: 'milestone-dev-1',
-    name: 'Core Components Complete',
-    description: 'All core frontend components have been developed and tested',
-    dueDate: new Date(2025, 0, 20),
-    isCompleted: false,
-    criticalPath: false,
-  },
-  {
-    id: 'milestone-dev-2',
-    name: 'API Development Complete',
-    description: 'All backend APIs are developed and documented',
-    dueDate: new Date(2025, 0, 25),
-    isCompleted: false,
-    criticalPath: true,
-  }
-];
-
-// Sample tasks for Testing Phase
-const testingTasks: PhaseTask[] = [
-  {
-    id: 'task-test-1',
-    name: 'Unit Testing Implementation',
-    description: 'Write and execute comprehensive unit tests',
-    startDate: new Date(2025, 1, 1), // February 1, 2025
-    endDate: new Date(2025, 1, 15),
-    progress: 0,
-    assigneeId: 'user-7',
-    assigneeName: 'Grace Lee',
-    priority: 'high',
-    status: 'todo',
-    dependencies: ['task-dev-1', 'task-dev-2'],
-  },
-  {
-    id: 'task-test-2',
-    name: 'Integration Testing',
-    description: 'Perform integration testing between frontend and backend',
-    startDate: new Date(2025, 1, 10),
-    endDate: new Date(2025, 1, 25),
-    progress: 0,
-    assigneeId: 'user-8',
-    assigneeName: 'Henry Clark',
-    priority: 'high',
-    status: 'todo',
-    dependencies: ['task-test-1'],
-  },
-  {
-    id: 'task-test-3',
-    name: 'User Acceptance Testing',
-    description: 'Conduct user acceptance testing with stakeholders',
-    startDate: new Date(2025, 1, 20),
-    endDate: new Date(2025, 2, 5), // March 5, 2025
-    progress: 0,
-    assigneeId: 'user-9',
-    assigneeName: 'Ivy Taylor',
-    priority: 'medium',
-    status: 'todo',
-    dependencies: ['task-test-2'],
-  }
-];
-
-// Sample milestones for Testing Phase
-const testingMilestones: PhaseMilestone[] = [
-  {
-    id: 'milestone-test-1',
-    name: 'All Tests Passing',
-    description: 'All unit and integration tests are passing',
-    dueDate: new Date(2025, 1, 25),
-    isCompleted: false,
-    criticalPath: true,
-  },
-  {
-    id: 'milestone-test-2',
-    name: 'UAT Sign-off',
-    description: 'User acceptance testing completed and signed off',
-    dueDate: new Date(2025, 2, 5),
-    isCompleted: false,
-    criticalPath: true,
-  }
-];
-
-// Sample tasks for Deployment Phase
-const deploymentTasks: PhaseTask[] = [
-  {
-    id: 'task-deploy-1',
-    name: 'Production Environment Setup',
-    description: 'Configure and set up production environment',
-    startDate: new Date(2025, 2, 6), // March 6, 2025
-    endDate: new Date(2025, 2, 12),
-    progress: 0,
-    assigneeId: 'user-10',
-    assigneeName: 'Jack Anderson',
-    priority: 'high',
-    status: 'todo',
-    dependencies: ['task-test-3'],
-  },
-  {
-    id: 'task-deploy-2',
-    name: 'Application Deployment',
-    description: 'Deploy application to production environment',
-    startDate: new Date(2025, 2, 13),
-    endDate: new Date(2025, 2, 15),
-    progress: 0,
-    assigneeId: 'user-11',
-    assigneeName: 'Kelly White',
-    priority: 'high',
-    status: 'todo',
-    dependencies: ['task-deploy-1'],
-  },
-  {
-    id: 'task-deploy-3',
-    name: 'Post-Deployment Monitoring',
-    description: 'Monitor application performance post-deployment',
-    startDate: new Date(2025, 2, 16),
-    endDate: new Date(2025, 2, 20),
-    progress: 0,
-    assigneeId: 'user-12',
-    assigneeName: 'Liam Garcia',
-    priority: 'medium',
-    status: 'todo',
-    dependencies: ['task-deploy-2'],
-  }
-];
-
-// Sample milestones for Deployment Phase
-const deploymentMilestones: PhaseMilestone[] = [
-  {
-    id: 'milestone-deploy-1',
-    name: 'Production Go-Live',
-    description: 'Application is live in production environment',
-    dueDate: new Date(2025, 2, 15),
-    isCompleted: false,
-    criticalPath: true,
-  },
-  {
-    id: 'milestone-deploy-2',
-    name: 'Project Handover',
-    description: 'Project handed over to maintenance team',
-    dueDate: new Date(2025, 2, 20),
-    isCompleted: false,
-    criticalPath: false,
-  }
-];
-
-// Sample project phases
-const samplePhases: ProjectPhase[] = [
-  {
-    id: 'phase-planning',
-    name: 'Planning & Analysis',
-    description: 'Initial project planning, requirements gathering, and technical analysis',
-    startDate: new Date(2024, 11, 1),
-    endDate: new Date(2024, 11, 15),
-    progress: 75,
-    color: '#1890ff',
-    status: 'in-progress',
-    tasks: planningTasks,
-    milestones: planningMilestones,
-  },
-  {
-    id: 'phase-development',
-    name: 'Development',
-    description: 'Core development of frontend, backend, and database components',
-    startDate: new Date(2024, 11, 16),
-    endDate: new Date(2025, 0, 31),
-    progress: 40,
-    color: '#52c41a',
-    status: 'in-progress',
-    tasks: developmentTasks,
-    milestones: developmentMilestones,
-  },
-  {
-    id: 'phase-testing',
-    name: 'Testing & QA',
-    description: 'Comprehensive testing including unit, integration, and user acceptance testing',
-    startDate: new Date(2025, 1, 1),
-    endDate: new Date(2025, 2, 5),
-    progress: 0,
-    color: '#faad14',
-    status: 'not-started',
-    tasks: testingTasks,
-    milestones: testingMilestones,
-  },
-  {
-    id: 'phase-deployment',
-    name: 'Deployment & Launch',
-    description: 'Production deployment and project launch activities',
-    startDate: new Date(2025, 2, 6),
-    endDate: new Date(2025, 2, 20),
-    progress: 0,
-    color: '#722ed1',
-    status: 'not-started',
-    tasks: deploymentTasks,
-    milestones: deploymentMilestones,
-  }
-];
-
-// Sample project roadmap
-export const sampleProjectRoadmap: ProjectRoadmap = {
-  id: 'roadmap-sample-project',
-  projectId: 'project-web-platform',
-  name: 'Web Platform Development Roadmap',
-  description: 'Comprehensive roadmap for developing a new web-based platform with modern technologies and agile methodologies',
-  startDate: new Date(2024, 11, 1),
-  endDate: new Date(2025, 2, 20),
-  phases: samplePhases,
-  createdAt: new Date(2024, 10, 15),
-  updatedAt: new Date(2024, 11, 1),
-};
-
-export default sampleProjectRoadmap;
--- a/worklenz-frontend/src/components/task-drawer/shared/info-tab/details/task-drawer-recurring-config/task-drawer-recurring-config.tsx
+++ b/worklenz-frontend/src/components/task-drawer/shared/info-tab/details/task-drawer-recurring-config/task-drawer-recurring-config.tsx
@@ -11,7 +11,11 @@ import {
  Skeleton,
  Row,
  Col,
+  DatePicker,
+  Tag,
+  Space,
 } from 'antd';
+import { CloseOutlined } from '@ant-design/icons';
 import { SettingOutlined } from '@ant-design/icons';
 import { useSocket } from '@/socket/socketContext';
 import { SocketEvents } from '@/shared/socket-events';
@@ -29,6 +33,7 @@ import { updateTaskCounts } from '@/features/task-management/task-management.sli
 import { taskRecurringApiService } from '@/api/tasks/task-recurring.api.service';
 import logger from '@/utils/errorLogger';
 import { setTaskRecurringSchedule } from '@/features/task-drawer/task-drawer.slice';
+import moment from 'moment-timezone';

 const monthlyDateOptions = Array.from({ length: 28 }, (_, i) => i + 1);

@@ -66,6 +71,21 @@ const TaskDrawerRecurringConfig = ({ task }: { task: ITaskViewModel }) => {

  const dayOptions = daysOfWeek.map(d => ({ label: d.label, value: d.value }));

+  // Get common timezones
+  const timezoneOptions = [
+    { label: 'UTC', value: 'UTC' },
+    { label: 'US Eastern', value: 'America/New_York' },
+    { label: 'US Central', value: 'America/Chicago' },
+    { label: 'US Mountain', value: 'America/Denver' },
+    { label: 'US Pacific', value: 'America/Los_Angeles' },
+    { label: 'Europe/London', value: 'Europe/London' },
+    { label: 'Europe/Paris', value: 'Europe/Paris' },
+    { label: 'Asia/Tokyo', value: 'Asia/Tokyo' },
+    { label: 'Asia/Shanghai', value: 'Asia/Shanghai' },
+    { label: 'Asia/Kolkata', value: 'Asia/Kolkata' },
+    { label: 'Australia/Sydney', value: 'Australia/Sydney' },
+  ];
+
  const [recurring, setRecurring] = useState(false);
  const [showConfig, setShowConfig] = useState(false);
  const [repeatOption, setRepeatOption] = useState<IRepeatOption>({});
@@ -80,6 +100,10 @@ const TaskDrawerRecurringConfig = ({ task }: { task: ITaskViewModel }) => {
  const [loadingData, setLoadingData] = useState(false);
  const [updatingData, setUpdatingData] = useState(false);
  const [scheduleData, setScheduleData] = useState<ITaskRecurringSchedule>({});
+  const [timezone, setTimezone] = useState('UTC');
+  const [endDate, setEndDate] = useState<moment.Moment | null>(null);
+  const [excludedDates, setExcludedDates] = useState<string[]>([]);
+  const [newExcludeDate, setNewExcludeDate] = useState<moment.Moment | null>(null);

  const handleChange = (checked: boolean) => {
    if (!task.id) return;
@@ -140,6 +164,9 @@ const TaskDrawerRecurringConfig = ({ task }: { task: ITaskViewModel }) => {
    const body: ITaskRecurringSchedule = {
      id: task.id,
      schedule_type: repeatOption.value,
+      timezone: timezone,
+      end_date: endDate ? endDate.format('YYYY-MM-DD') : null,
+      excluded_dates: excludedDates,
    };

    switch (repeatOption.value) {
@@ -213,13 +240,16 @@ const TaskDrawerRecurringConfig = ({ task }: { task: ITaskViewModel }) => {
          const selected = repeatOptions.find(e => e.value == res.body.schedule_type);
          if (selected) {
            setRepeatOption(selected);
-            setSelectedMonthlyDate(scheduleData.date_of_month || 1);
-            setSelectedMonthlyDay(scheduleData.day_of_month || 0);
-            setSelectedMonthlyWeek(scheduleData.week_of_month || 0);
-            setIntervalDays(scheduleData.interval_days || 1);
-            setIntervalWeeks(scheduleData.interval_weeks || 1);
-            setIntervalMonths(scheduleData.interval_months || 1);
-            setMonthlyOption(selectedMonthlyDate ? 'date' : 'day');
+            setSelectedMonthlyDate(res.body.date_of_month || 1);
+            setSelectedMonthlyDay(res.body.day_of_month || 0);
+            setSelectedMonthlyWeek(res.body.week_of_month || 0);
+            setIntervalDays(res.body.interval_days || 1);
+            setIntervalWeeks(res.body.interval_weeks || 1);
+            setIntervalMonths(res.body.interval_months || 1);
+            setTimezone(res.body.timezone || 'UTC');
+            setEndDate(res.body.end_date ? moment(res.body.end_date) : null);
+            setExcludedDates(res.body.excluded_dates || []);
+            setMonthlyOption(res.body.date_of_month ? 'date' : 'day');
            updateDaysOfWeek();
          }
        }
@@ -365,6 +395,69 @@ const TaskDrawerRecurringConfig = ({ task }: { task: ITaskViewModel }) => {
                        />
                      </Form.Item>
                    )}
+
+                    {/* Timezone Selection */}
+                    <Form.Item label={t('timezone')}>
+                      <Select
+                        value={timezone}
+                        onChange={setTimezone}
+                        options={timezoneOptions}
+                        style={{ width: '100%' }}
+                      />
+                    </Form.Item>
+
+                    {/* End Date */}
+                    <Form.Item label={t('endDate')}>
+                      <DatePicker
+                        value={endDate}
+                        onChange={setEndDate}
+                        style={{ width: '100%' }}
+                        placeholder={t('selectEndDate')}
+                        disabledDate={(current) => current && current < moment().endOf('day')}
+                      />
+                    </Form.Item>
+
+                    {/* Excluded Dates */}
+                    <Form.Item label={t('excludedDates')}>
+                      <Space direction="vertical" style={{ width: '100%' }}>
+                        <DatePicker
+                          value={newExcludeDate}
+                          onChange={setNewExcludeDate}
+                          style={{ width: '100%' }}
+                          placeholder={t('selectDateToExclude')}
+                          disabledDate={(current) => current && current < moment().endOf('day')}
+                        />
+                        {newExcludeDate && (
+                          <Button
+                            size="small"
+                            onClick={() => {
+                              const dateStr = newExcludeDate.format('YYYY-MM-DD');
+                              if (!excludedDates.includes(dateStr)) {
+                                setExcludedDates([...excludedDates, dateStr]);
+                                setNewExcludeDate(null);
+                              }
+                            }}
+                          >
+                            {t('addExcludedDate')}
+                          </Button>
+                        )}
+                        <div style={{ marginTop: 8 }}>
+                          {excludedDates.map((date) => (
+                            <Tag
+                              key={date}
+                              closable
+                              onClose={() => {
+                                setExcludedDates(excludedDates.filter(d => d !== date));
+                              }}
+                              style={{ marginBottom: 4 }}
+                            >
+                              {date}
+                            </Tag>
+                          ))}
+                        </div>
+                      </Space>
+                    </Form.Item>
+
                    <Form.Item style={{ marginBottom: 0, textAlign: 'right' }}>
                      <Button
                        type="primary"
--- a/worklenz-frontend/src/pages/GanttDemoPage.tsx
+++ b/worklenz-frontend/src/pages/GanttDemoPage.tsx
@@ -1,8 +0,0 @@
-import React from 'react';
-import { AdvancedGanttDemo } from '../components/advanced-gantt';
-
-const GanttDemoPage: React.FC = () => {
-  return <AdvancedGanttDemo />;
-};
-
-export default GanttDemoPage;
--- a/worklenz-frontend/src/pages/projects/ProjectGanttView.tsx
+++ b/worklenz-frontend/src/pages/projects/ProjectGanttView.tsx
@@ -1,63 +0,0 @@
-import React, { useMemo } from 'react';
-import { useParams } from 'react-router-dom';
-import { AdvancedGanttChart } from '../../components/advanced-gantt';
-import { useAppSelector } from '../../hooks/useAppSelector';
-import { GanttTask } from '../../types/advanced-gantt.types';
-
-const ProjectGanttView: React.FC = () => {
-  const { projectId } = useParams<{ projectId: string }>();
-  
-  // Get tasks from your Redux store (adjust based on your actual state structure)
-  const tasks = useAppSelector(state => state.tasksReducer?.tasks || []);
-  
-  // Transform your tasks to GanttTask format
-  const ganttTasks = useMemo((): GanttTask[] => {
-    return tasks.map(task => ({
-      id: task.id,
-      name: task.name,
-      startDate: task.start_date ? new Date(task.start_date) : new Date(),
-      endDate: task.end_date ? new Date(task.end_date) : new Date(),
-      progress: task.progress || 0,
-      type: 'task',
-      status: task.status || 'not-started',
-      priority: task.priority || 'medium',
-      assignee: task.assignee ? {
-        id: task.assignee.id,
-        name: task.assignee.name,
-        avatar: task.assignee.avatar,
-      } : undefined,
-      parent: task.parent_task_id,
-      level: task.level || 0,
-      // Map other fields as needed
-    }));
-  }, [tasks]);
-
-  const handleTaskUpdate = (taskId: string, updates: Partial<GanttTask>) => {
-    // Implement your task update logic here
-    console.log('Update task:', taskId, updates);
-    // Dispatch Redux action to update task
-  };
-
-  const handleTaskMove = (taskId: string, newDates: { start: Date; end: Date }) => {
-    // Implement your task move logic here
-    console.log('Move task:', taskId, newDates);
-    // Dispatch Redux action to update task dates
-  };
-
-  return (
-    <div className="project-gantt-view h-full">
-      <AdvancedGanttChart
-        tasks={ganttTasks}
-        onTaskUpdate={handleTaskUpdate}
-        onTaskMove={handleTaskMove}
-        enableDragDrop={true}
-        enableResize={true}
-        enableProgressEdit={true}
-        enableInlineEdit={true}
-        className="h-full"
-      />
-    </div>
-  );
-};
-
-export default ProjectGanttView;
--- a/worklenz-frontend/src/types/advanced-gantt.types.ts
+++ b/worklenz-frontend/src/types/advanced-gantt.types.ts
@@ -1,307 +0,0 @@
-import { ReactNode } from 'react';
-
-// Core Task Interface
-export interface GanttTask {
-  id: string;
-  name: string;
-  startDate: Date;
-  endDate: Date;
-  progress: number;
-  duration?: number; // in days
-  parent?: string;
-  type: 'task' | 'milestone' | 'project';
-  status: 'not-started' | 'in-progress' | 'completed' | 'on-hold' | 'overdue';
-  priority: 'low' | 'medium' | 'high' | 'critical';
-  assignee?: {
-    id: string;
-    name: string;
-    avatar?: string;
-  };
-  dependencies?: string[];
-  description?: string;
-  tags?: string[];
-  color?: string;
-  isCollapsed?: boolean;
-  level?: number; // for hierarchical display
-  hasChildren?: boolean;
-  isExpanded?: boolean;
-}
-
-// Column Configuration
-export interface ColumnConfig {
-  field: keyof GanttTask | string;
-  title: string;
-  width: number;
-  minWidth?: number;
-  maxWidth?: number;
-  resizable: boolean;
-  sortable: boolean;
-  fixed: boolean;
-  align?: 'left' | 'center' | 'right';
-  renderer?: (value: any, task: GanttTask) => ReactNode;
-  editor?: 'text' | 'date' | 'select' | 'number' | 'progress';
-  editorOptions?: any;
-}
-
-// Timeline Configuration
-export interface TimelineConfig {
-  topTier: {
-    unit: 'year' | 'month' | 'week' | 'day';
-    format: string;
-    height?: number;
-  };
-  bottomTier: {
-    unit: 'month' | 'week' | 'day' | 'hour';
-    format: string;
-    height?: number;
-  };
-  showWeekends: boolean;
-  showNonWorkingDays: boolean;
-  holidays: Holiday[];
-  workingDays: number[]; // 0-6, Sunday-Saturday
-  workingHours: {
-    start: number; // 0-23
-    end: number; // 0-23
-  };
-  minDate?: Date;
-  maxDate?: Date;
-  dayWidth: number; // pixels per day
-}
-
-// Holiday Interface
-export interface Holiday {
-  date: Date;
-  name: string;
-  type: 'national' | 'company' | 'religious' | 'custom';
-  recurring?: boolean;
-  color?: string;
-}
-
-// Virtual Scrolling Configuration
-export interface VirtualScrollConfig {
-  enableRowVirtualization: boolean;
-  enableTimelineVirtualization: boolean;
-  bufferSize: number;
-  itemHeight: number;
-  overscan?: number;
-}
-
-// Drag and Drop State
-export interface DragState {
-  isDragging: boolean;
-  dragType: 'move' | 'resize-start' | 'resize-end' | 'progress' | 'link';
-  taskId: string;
-  initialPosition: { x: number; y: number };
-  currentPosition?: { x: number; y: number };
-  initialDates: { start: Date; end: Date };
-  initialProgress?: number;
-  snapToGrid?: boolean;
-  constraints?: {
-    minDate?: Date;
-    maxDate?: Date;
-    minDuration?: number;
-    maxDuration?: number;
-  };
-}
-
-// Zoom Levels
-export interface ZoomLevel {
-  name: string;
-  dayWidth: number;
-  topTier: TimelineConfig['topTier'];
-  bottomTier: TimelineConfig['bottomTier'];
-  scale: number;
-}
-
-// Selection State
-export interface SelectionState {
-  selectedTasks: string[];
-  selectedRows: number[];
-  selectionRange?: {
-    start: { row: number; col: number };
-    end: { row: number; col: number };
-  };
-  focusedTask?: string;
-}
-
-// Gantt View State
-export interface GanttViewState {
-  zoomLevel: number;
-  scrollPosition: { x: number; y: number };
-  viewportSize: { width: number; height: number };
-  splitterPosition: number; // percentage for grid/timeline split
-  showCriticalPath: boolean;
-  showBaseline: boolean;
-  showProgress: boolean;
-  showDependencies: boolean;
-  autoSchedule: boolean;
-  readOnly: boolean;
-}
-
-// Performance Metrics
-export interface PerformanceMetrics {
-  renderTime: number;
-  taskCount: number;
-  visibleTaskCount: number;
-  memoryUsage?: number;
-  fps?: number;
-}
-
-// Event Handlers
-export type TaskEventHandler<T = void> = (task: GanttTask, event: MouseEvent | TouchEvent) => T;
-export type DragEventHandler = (taskId: string, newDates: { start: Date; end: Date }) => void;
-export type ResizeEventHandler = (taskId: string, newDates: { start: Date; end: Date }) => void;
-export type ProgressEventHandler = (taskId: string, progress: number) => void;
-export type SelectionEventHandler = (selectedTasks: string[]) => void;
-export type ColumnResizeHandler = (columnField: string, newWidth: number) => void;
-
-// Gantt Actions (for useReducer)
-export type GanttAction =
-  | { type: 'SET_TASKS'; payload: GanttTask[] }
-  | { type: 'UPDATE_TASK'; payload: { id: string; updates: Partial<GanttTask> } }
-  | { type: 'ADD_TASK'; payload: GanttTask }
-  | { type: 'DELETE_TASK'; payload: string }
-  | { type: 'SET_SELECTION'; payload: string[] }
-  | { type: 'SET_DRAG_STATE'; payload: DragState | null }
-  | { type: 'SET_ZOOM_LEVEL'; payload: number }
-  | { type: 'SET_SCROLL_POSITION'; payload: { x: number; y: number } }
-  | { type: 'SET_SPLITTER_POSITION'; payload: number }
-  | { type: 'TOGGLE_TASK_EXPANSION'; payload: string }
-  | { type: 'SET_VIEW_STATE'; payload: Partial<GanttViewState> }
-  | { type: 'UPDATE_COLUMN_WIDTH'; payload: { field: string; width: number } };
-
-// Main Gantt State
-export interface GanttState {
-  tasks: GanttTask[];
-  columns: ColumnConfig[];
-  timelineConfig: TimelineConfig;
-  virtualScrollConfig: VirtualScrollConfig;
-  dragState: DragState | null;
-  selectionState: SelectionState;
-  viewState: GanttViewState;
-  zoomLevels: ZoomLevel[];
-  performanceMetrics: PerformanceMetrics;
-}
-
-// Gantt Chart Props
-export interface AdvancedGanttProps {
-  // Data
-  tasks: GanttTask[];
-  columns?: ColumnConfig[];
-  
-  // Configuration
-  timelineConfig?: Partial<TimelineConfig>;
-  virtualScrollConfig?: Partial<VirtualScrollConfig>;
-  zoomLevels?: ZoomLevel[];
-  
-  // Initial State
-  initialViewState?: Partial<GanttViewState>;
-  initialSelection?: string[];
-  
-  // Event Handlers
-  onTaskUpdate?: (taskId: string, updates: Partial<GanttTask>) => void;
-  onTaskCreate?: (task: Omit<GanttTask, 'id'>) => void;
-  onTaskDelete?: (taskId: string) => void;
-  onTaskMove?: DragEventHandler;
-  onTaskResize?: ResizeEventHandler;
-  onProgressChange?: ProgressEventHandler;
-  onSelectionChange?: SelectionEventHandler;
-  onColumnResize?: ColumnResizeHandler;
-  onDependencyCreate?: (fromTaskId: string, toTaskId: string) => void;
-  onDependencyDelete?: (fromTaskId: string, toTaskId: string) => void;
-  
-  // UI Customization
-  className?: string;
-  style?: React.CSSProperties;
-  theme?: 'light' | 'dark' | 'auto';
-  locale?: string;
-  
-  // Feature Flags
-  enableDragDrop?: boolean;
-  enableResize?: boolean;
-  enableProgressEdit?: boolean;
-  enableInlineEdit?: boolean;
-  enableContextMenu?: boolean;
-  enableTooltips?: boolean;
-  enableExport?: boolean;
-  enablePrint?: boolean;
-  
-  // Performance Options
-  enableVirtualScrolling?: boolean;
-  enableDebouncing?: boolean;
-  debounceDelay?: number;
-  maxVisibleTasks?: number;
-}
-
-// Context Menu Options
-export interface ContextMenuOption {
-  id: string;
-  label: string;
-  icon?: ReactNode;
-  disabled?: boolean;
-  separator?: boolean;
-  children?: ContextMenuOption[];
-  onClick?: (task?: GanttTask) => void;
-}
-
-// Export Options
-export interface ExportOptions {
-  format: 'png' | 'pdf' | 'svg' | 'json' | 'csv' | 'xlsx';
-  includeColumns?: string[];
-  dateRange?: { start: Date; end: Date };
-  filename?: string;
-  paperSize?: 'A4' | 'A3' | 'Letter' | 'Legal';
-  orientation?: 'portrait' | 'landscape';
-  scale?: number;
-}
-
-// Filter and Search
-export interface FilterConfig {
-  field: string;
-  operator: 'equals' | 'contains' | 'startsWith' | 'endsWith' | 'greaterThan' | 'lessThan' | 'between';
-  value: any;
-  logic?: 'and' | 'or';
-}
-
-export interface SearchConfig {
-  query: string;
-  fields: string[];
-  caseSensitive?: boolean;
-  wholeWord?: boolean;
-  regex?: boolean;
-}
-
-// Baseline and Critical Path
-export interface TaskBaseline {
-  taskId: string;
-  baselineStart: Date;
-  baselineEnd: Date;
-  baselineDuration: number;
-  baselineProgress: number;
-  variance?: number; // days
-}
-
-export interface CriticalPath {
-  taskIds: string[];
-  totalDuration: number;
-  slack: number; // days of buffer
-}
-
-// Undo/Redo
-export interface HistoryState {
-  past: GanttState[];
-  present: GanttState;
-  future: GanttState[];
-  maxHistorySize: number;
-}
-
-// Keyboard Shortcuts
-export interface KeyboardShortcut {
-  key: string;
-  ctrl?: boolean;
-  shift?: boolean;
-  alt?: boolean;
-  action: string;
-  description: string;
-  handler: (event: KeyboardEvent) => void;
-}
--- a/worklenz-frontend/src/types/project-roadmap.types.ts
+++ b/worklenz-frontend/src/types/project-roadmap.types.ts
@@ -1,62 +0,0 @@
-export interface ProjectPhase {
-  id: string;
-  name: string;
-  description: string;
-  startDate: Date;
-  endDate: Date;
-  progress: number;
-  color: string;
-  status: 'not-started' | 'in-progress' | 'completed' | 'on-hold';
-  tasks: PhaseTask[];
-  milestones: PhaseMilestone[];
-}
-
-export interface PhaseTask {
-  id: string;
-  name: string;
-  description?: string;
-  startDate: Date;
-  endDate: Date;
-  progress: number;
-  assigneeId?: string;
-  assigneeName?: string;
-  priority: 'low' | 'medium' | 'high';
-  status: 'todo' | 'in-progress' | 'done';
-  dependencies?: string[];
-}
-
-export interface PhaseMilestone {
-  id: string;
-  name: string;
-  description?: string;
-  dueDate: Date;
-  isCompleted: boolean;
-  criticalPath: boolean;
-}
-
-export interface ProjectRoadmap {
-  id: string;
-  projectId: string;
-  name: string;
-  description?: string;
-  startDate: Date;
-  endDate: Date;
-  phases: ProjectPhase[];
-  createdAt: Date;
-  updatedAt: Date;
-}
-
-export interface GanttViewOptions {
-  viewMode: 'day' | 'week' | 'month' | 'year';
-  showTasks: boolean;
-  showMilestones: boolean;
-  groupByPhase: boolean;
-}
-
-export interface PhaseModalData extends ProjectPhase {
-  taskCount: number;
-  completedTaskCount: number;
-  milestoneCount: number;
-  completedMilestoneCount: number;
-  teamMembers: string[];
-}
--- a/worklenz-frontend/src/types/tasks/task-recurring-schedule.ts
+++ b/worklenz-frontend/src/types/tasks/task-recurring-schedule.ts
@@ -18,6 +18,9 @@ export interface ITaskRecurringSchedule {
  interval_weeks?: number | null;
  schedule_type?: ITaskRecurring;
  week_of_month?: number | null;
+  timezone?: string;
+  end_date?: string | null;
+  excluded_dates?: string[] | null;
 }

 export interface IRepeatOption {
--- a/worklenz-frontend/src/utils/gantt-performance.ts
+++ b/worklenz-frontend/src/utils/gantt-performance.ts
@@ -1,408 +0,0 @@
-import { useMemo, useCallback, useRef, useEffect } from 'react';
-import { GanttTask, PerformanceMetrics } from '../types/advanced-gantt.types';
-
-// Debounce utility for drag operations
-export function useDebounce<T extends (...args: any[]) => any>(
-  callback: T,
-  delay: number
-): T {
-  const timeoutRef = useRef<NodeJS.Timeout>();
-  
-  return useCallback((...args: Parameters<T>) => {
-    if (timeoutRef.current) {
-      clearTimeout(timeoutRef.current);
-    }
-    
-    timeoutRef.current = setTimeout(() => {
-      callback(...args);
-    }, delay);
-  }, [callback, delay]) as T;
-}
-
-// Throttle utility for scroll events
-export function useThrottle<T extends (...args: any[]) => any>(
-  callback: T,
-  delay: number
-): T {
-  const lastCall = useRef<number>(0);
-  
-  return useCallback((...args: Parameters<T>) => {
-    const now = Date.now();
-    if (now - lastCall.current >= delay) {
-      lastCall.current = now;
-      callback(...args);
-    }
-  }, [callback, delay]) as T;
-}
-
-// Memoized task calculations
-export const useTaskCalculations = (tasks: GanttTask[]) => {
-  return useMemo(() => {
-    const taskMap = new Map<string, GanttTask>();
-    const parentChildMap = new Map<string, string[]>();
-    const dependencyMap = new Map<string, string[]>();
-    
-    // Build maps for efficient lookups
-    tasks.forEach(task => {
-      taskMap.set(task.id, task);
-      
-      if (task.parent) {
-        if (!parentChildMap.has(task.parent)) {
-          parentChildMap.set(task.parent, []);
-        }
-        parentChildMap.get(task.parent)!.push(task.id);
-      }
-      
-      if (task.dependencies) {
-        dependencyMap.set(task.id, task.dependencies);
-      }
-    });
-    
-    return {
-      taskMap,
-      parentChildMap,
-      dependencyMap,
-      totalTasks: tasks.length,
-      projectTasks: tasks.filter(t => t.type === 'project'),
-      milestones: tasks.filter(t => t.type === 'milestone'),
-      regularTasks: tasks.filter(t => t.type === 'task'),
-    };
-  }, [tasks]);
-};
-
-// Virtual scrolling calculations
-export interface VirtualScrollData {
-  startIndex: number;
-  endIndex: number;
-  visibleItems: GanttTask[];
-  totalHeight: number;
-  offsetY: number;
-}
-
-export const useVirtualScrolling = (
-  tasks: GanttTask[],
-  containerHeight: number,
-  itemHeight: number,
-  scrollTop: number,
-  overscan: number = 5
-): VirtualScrollData => {
-  return useMemo(() => {
-    const totalHeight = tasks.length * itemHeight;
-    const startIndex = Math.max(0, Math.floor(scrollTop / itemHeight) - overscan);
-    const endIndex = Math.min(
-      tasks.length - 1,
-      Math.ceil((scrollTop + containerHeight) / itemHeight) + overscan
-    );
-    const visibleItems = tasks.slice(startIndex, endIndex + 1);
-    const offsetY = startIndex * itemHeight;
-    
-    return {
-      startIndex,
-      endIndex,
-      visibleItems,
-      totalHeight,
-      offsetY,
-    };
-  }, [tasks, containerHeight, itemHeight, scrollTop, overscan]);
-};
-
-// Timeline virtual scrolling
-export interface TimelineVirtualData {
-  startDate: Date;
-  endDate: Date;
-  visibleDays: Date[];
-  totalWidth: number;
-  offsetX: number;
-}
-
-export const useTimelineVirtualScrolling = (
-  projectStartDate: Date,
-  projectEndDate: Date,
-  dayWidth: number,
-  containerWidth: number,
-  scrollLeft: number,
-  overscan: number = 10
-): TimelineVirtualData => {
-  return useMemo(() => {
-    const totalDays = Math.ceil((projectEndDate.getTime() - projectStartDate.getTime()) / (1000 * 60 * 60 * 24));
-    const totalWidth = totalDays * dayWidth;
-    
-    const startDayIndex = Math.max(0, Math.floor(scrollLeft / dayWidth) - overscan);
-    const endDayIndex = Math.min(
-      totalDays - 1,
-      Math.ceil((scrollLeft + containerWidth) / dayWidth) + overscan
-    );
-    
-    const visibleDays: Date[] = [];
-    for (let i = startDayIndex; i <= endDayIndex; i++) {
-      const date = new Date(projectStartDate);
-      date.setDate(date.getDate() + i);
-      visibleDays.push(date);
-    }
-    
-    const offsetX = startDayIndex * dayWidth;
-    const startDate = new Date(projectStartDate);
-    startDate.setDate(startDate.getDate() + startDayIndex);
-    
-    const endDate = new Date(projectStartDate);
-    endDate.setDate(endDate.getDate() + endDayIndex);
-    
-    return {
-      startDate,
-      endDate,
-      visibleDays,
-      totalWidth,
-      offsetX,
-    };
-  }, [projectStartDate, projectEndDate, dayWidth, containerWidth, scrollLeft, overscan]);
-};
-
-// Performance monitoring hook
-export const usePerformanceMonitoring = (): {
-  metrics: PerformanceMetrics;
-  startMeasure: (name: string) => void;
-  endMeasure: (name: string) => void;
-  recordMetric: (name: string, value: number) => void;
-} => {
-  const metricsRef = useRef<PerformanceMetrics>({
-    renderTime: 0,
-    taskCount: 0,
-    visibleTaskCount: 0,
-  });
-  
-  const measurementsRef = useRef<Map<string, number>>(new Map());
-  
-  const startMeasure = useCallback((name: string) => {
-    measurementsRef.current.set(name, performance.now());
-  }, []);
-  
-  const endMeasure = useCallback((name: string) => {
-    const startTime = measurementsRef.current.get(name);
-    if (startTime) {
-      const duration = performance.now() - startTime;
-      measurementsRef.current.delete(name);
-      
-      if (name === 'render') {
-        metricsRef.current.renderTime = duration;
-      }
-    }
-  }, []);
-  
-  const recordMetric = useCallback((name: string, value: number) => {
-    switch (name) {
-      case 'taskCount':
-        metricsRef.current.taskCount = value;
-        break;
-      case 'visibleTaskCount':
-        metricsRef.current.visibleTaskCount = value;
-        break;
-      case 'memoryUsage':
-        metricsRef.current.memoryUsage = value;
-        break;
-      case 'fps':
-        metricsRef.current.fps = value;
-        break;
-    }
-  }, []);
-  
-  return {
-    metrics: metricsRef.current,
-    startMeasure,
-    endMeasure,
-    recordMetric,
-  };
-};
-
-// Intersection Observer for lazy loading
-export const useIntersectionObserver = (
-  callback: (entries: IntersectionObserverEntry[]) => void,
-  options?: IntersectionObserverInit
-) => {
-  const targetRef = useRef<HTMLElement>(null);
-  const observerRef = useRef<IntersectionObserver>();
-  
-  useEffect(() => {
-    if (!targetRef.current) return;
-    
-    observerRef.current = new IntersectionObserver(callback, {
-      root: null,
-      rootMargin: '100px',
-      threshold: 0.1,
-      ...options,
-    });
-    
-    observerRef.current.observe(targetRef.current);
-    
-    return () => {
-      if (observerRef.current) {
-        observerRef.current.disconnect();
-      }
-    };
-  }, [callback, options]);
-  
-  return targetRef;
-};
-
-// Date calculations optimization
-export const useDateCalculations = () => {
-  return useMemo(() => {
-    const cache = new Map<string, number>();
-    
-    const getDaysBetween = (start: Date, end: Date): number => {
-      const key = `${start.getTime()}-${end.getTime()}`;
-      if (cache.has(key)) {
-        return cache.get(key)!;
-      }
-      
-      const days = Math.ceil((end.getTime() - start.getTime()) / (1000 * 60 * 60 * 24));
-      cache.set(key, days);
-      return days;
-    };
-    
-    const addDays = (date: Date, days: number): Date => {
-      const result = new Date(date);
-      result.setDate(result.getDate() + days);
-      return result;
-    };
-    
-    const isWeekend = (date: Date): boolean => {
-      const day = date.getDay();
-      return day === 0 || day === 6; // Sunday or Saturday
-    };
-    
-    const isWorkingDay = (date: Date, workingDays: number[]): boolean => {
-      return workingDays.includes(date.getDay());
-    };
-    
-    const getWorkingDaysBetween = (start: Date, end: Date, workingDays: number[]): number => {
-      let count = 0;
-      const current = new Date(start);
-      
-      while (current <= end) {
-        if (isWorkingDay(current, workingDays)) {
-          count++;
-        }
-        current.setDate(current.getDate() + 1);
-      }
-      
-      return count;
-    };
-    
-    return {
-      getDaysBetween,
-      addDays,
-      isWeekend,
-      isWorkingDay,
-      getWorkingDaysBetween,
-      clearCache: () => cache.clear(),
-    };
-  }, []);
-};
-
-// Task position calculations
-export const useTaskPositions = (
-  tasks: GanttTask[],
-  timelineStart: Date,
-  dayWidth: number
-) => {
-  return useMemo(() => {
-    const positions = new Map<string, { x: number; width: number; y: number }>();
-    
-    tasks.forEach((task, index) => {
-      const startDays = Math.floor((task.startDate.getTime() - timelineStart.getTime()) / (1000 * 60 * 60 * 24));
-      const endDays = Math.floor((task.endDate.getTime() - timelineStart.getTime()) / (1000 * 60 * 60 * 24));
-      
-      positions.set(task.id, {
-        x: startDays * dayWidth,
-        width: Math.max(1, (endDays - startDays) * dayWidth),
-        y: index * 40, // Assuming 40px row height
-      });
-    });
-    
-    return positions;
-  }, [tasks, timelineStart, dayWidth]);
-};
-
-// Memory management utilities
-export const useMemoryManagement = () => {
-  const cleanupFunctions = useRef<Array<() => void>>([]);
-  
-  const addCleanup = useCallback((cleanup: () => void) => {
-    cleanupFunctions.current.push(cleanup);
-  }, []);
-  
-  const runCleanup = useCallback(() => {
-    cleanupFunctions.current.forEach(cleanup => cleanup());
-    cleanupFunctions.current = [];
-  }, []);
-  
-  useEffect(() => {
-    return runCleanup;
-  }, [runCleanup]);
-  
-  return { addCleanup, runCleanup };
-};
-
-// Batch update utility for multiple task changes
-export const useBatchUpdates = <T>(
-  updateFunction: (updates: T[]) => void,
-  delay: number = 100
-) => {
-  const batchRef = useRef<T[]>([]);
-  const timeoutRef = useRef<NodeJS.Timeout>();
-  
-  const addUpdate = useCallback((update: T) => {
-    batchRef.current.push(update);
-    
-    if (timeoutRef.current) {
-      clearTimeout(timeoutRef.current);
-    }
-    
-    timeoutRef.current = setTimeout(() => {
-      if (batchRef.current.length > 0) {
-        updateFunction([...batchRef.current]);
-        batchRef.current = [];
-      }
-    }, delay);
-  }, [updateFunction, delay]);
-  
-  const flushUpdates = useCallback(() => {
-    if (timeoutRef.current) {
-      clearTimeout(timeoutRef.current);
-    }
-    
-    if (batchRef.current.length > 0) {
-      updateFunction([...batchRef.current]);
-      batchRef.current = [];
-    }
-  }, [updateFunction]);
-  
-  return { addUpdate, flushUpdates };
-};
-
-// FPS monitoring
-export const useFPSMonitoring = () => {
-  const fpsRef = useRef<number>(0);
-  const frameCountRef = useRef<number>(0);
-  const lastTimeRef = useRef<number>(performance.now());
-  
-  const measureFPS = useCallback(() => {
-    frameCountRef.current++;
-    const now = performance.now();
-    
-    if (now - lastTimeRef.current >= 1000) {
-      fpsRef.current = Math.round((frameCountRef.current * 1000) / (now - lastTimeRef.current));
-      frameCountRef.current = 0;
-      lastTimeRef.current = now;
-    }
-    
-    requestAnimationFrame(measureFPS);
-  }, []);
-  
-  useEffect(() => {
-    const rafId = requestAnimationFrame(measureFPS);
-    return () => cancelAnimationFrame(rafId);
-  }, [measureFPS]);
-  
-  return fpsRef.current;
-};