diff --git a/.cursor/rules/backend-java.mdc b/.cursor/rules/backend-java.mdc
new file mode 100644
index 000000000000..6ae981cfde76
--- /dev/null
+++ b/.cursor/rules/backend-java.mdc
@@ -0,0 +1,143 @@
+---
+description:
+globs: app/server/**/*.java
+alwaysApply: false
+---
+# Java / Spring Boot Backend Conventions
+
+## Tech Stack
+
+- Java 25, Spring Boot 3.5, Spring WebFlux (fully reactive), MongoDB, Maven
+- Formatting: Palantir Java Format via `mvn spotless:apply` (auto-runs on pre-commit)
+
+## Project Structure
+
+Multi-module Maven project under `app/server/`:
+
+```text
+appsmith-server/       — Main server module (controllers, services, repositories, domains)
+appsmith-interfaces/   — Shared contracts (models, exceptions, plugin interfaces)
+appsmith-plugins/      — 25+ database/API connector plugins
+appsmith-git/          — Git integration module
+reactive-caching/      — Custom reactive caching framework
+```
+
+Within `appsmith-server`, packages are organized by feature domain, each with `ce/` and optionally `ce_compatible/` sub-packages.
+
+## CE-EE Service Pattern (Mandatory for all extensible components)
+
+### Three-tier inheritance
+
+```text
+Interface: ServiceCE            → ServiceCECompatible            → Service
+Impl:      ServiceCEImpl        → ServiceCECompatibleImpl        → ServiceImpl (@Service)
+Package:   com.x.services.ce      com.x.services.ce_compatible     com.x.services
+```
+
+### Rules
+
+- `@Service` / `@Component` annotation on CE-Compatible and final `*Impl` classes (not on CE base classes)
+- CE impl contains all business logic
+- CE-Compatible is an empty pass-through in CE repo (EE overrides it for graceful degradation)
+- Final `*Impl` is an empty pass-through in CE repo (EE overrides it for enterprise features)
+- Use `protected` methods in CE impl to create override hooks for EE
+- This pattern applies to: services, repositories, controllers, solutions, helpers, configurations
+
+### When to create the CE-Compatible layer
+
+Always. Even if there's no current EE override, create the empty scaffolding so EE can extend later without modifying CE files.
+
+## Controller Conventions
+
+```text
+CE class (in controllers/ce/): All endpoint logic, NOT annotated as @RestController
+EE class (in controllers/):    @RestController + @RequestMapping, empty body, extends CE
+```
+
+- URL paths: `/api/v1/{resource}` — all paths defined in `UrlCE.java` constants
+- Response: always `Mono<ResponseDTO<T>>` — every response wrapped in `ResponseDTO`
+- `@JsonView(Views.Public.class)` on every endpoint method
+- Zero business logic in controllers — delegate entirely to services
+- No error handling in controllers — handled by global `@ControllerAdvice` (`GlobalExceptionHandler`)
+
+## Repository Conventions
+
+Dual hierarchy:
+- `BaseRepository` (extends `ReactiveMongoRepository`) — standard CRUD
+- `AppsmithRepository` (custom) — ACL-aware queries via `queryBuilder()` fluent API
+
+```java
+queryBuilder()
+    .criteria(Bridge.equal(Application.Fields.workspaceId, workspaceId))
+    .permission(aclPermission)
+    .all();
+```
+
+- No `@Query` annotations — use the `Bridge` query builder exclusively
+- Field references via Lombok `@FieldNameConstants` (`Fields` inner class)
+- Soft deletes: `archive()` sets `deletedAt`; queries auto-filter deleted records
+
+## Domain / DTO Conventions
+
+Hierarchy: `BaseDomain` (id, policyMap, timestamps) → `GitSyncedDomain` → `RefAwareDomain`
+
+- `@Getter`, `@Setter`, `@ToString` on domains — **not** `@Data` (avoids generated equals/hashCode)
+- `@FieldNameConstants` on all domains/DTOs for type-safe field references
+- `@JsonView` annotations control API visibility (`Views.Public.class`, `Views.Internal.class`, `Git.class`, `FromRequest.class`)
+- `@Transient` for computed fields not persisted to MongoDB
+- Domains/DTOs also follow CE-EE split: `ActionDTO extends ActionCE_DTO`
+
+## Dependency Injection
+
+- Constructor-based injection exclusively (no `@Autowired` on fields)
+- Use `@RequiredArgsConstructor` or `@AllArgsConstructor` (Lombok)
+- `@Lazy` to break circular dependencies
+- `@Autowired(required = false)` for optional dependencies
+
+## Reactive Patterns
+
+All service methods return `Mono<T>` or `Flux<T>`. Key patterns:
+
+- `.switchIfEmpty(Mono.error(new AppsmithException(...)))` — standard "not found"
+- `Mono.cache()` — prevent duplicate subscriptions when a Mono feeds multiple operators
+- `Mono.zip()` / `.zipWith()` / `.zipWhen()` — combine parallel or dependent operations
+- `Mono.defer()` — lazy evaluation inside `.switchIfEmpty()` and `.then()`
+- `.flatMap()` chains — primary mechanism for sequential reactive operations
+- `.onErrorResume()` — graceful degradation
+- `.onErrorMap()` — translate errors to `AppsmithException`
+- Never block reactive streams — no `.block()` in production code
+
+## Error Handling
+
+- `AppsmithException` wraps `AppsmithError` enum (100+ entries with HTTP status, error code `AE-{DOMAIN}-{NUMBER}`, message template)
+- Throw via `new AppsmithException(AppsmithError.SOME_ERROR, args...)`
+- Global handler (`GlobalExceptionHandler`) catches and returns `ResponseDTO<ErrorDTO>`
+- Plugin errors: `AppsmithPluginException` wraps `BasePluginError`
+
+## Feature Flags
+
+- `@FeatureFlagged(featureFlagName = FeatureFlagEnum.XXX)` on EE methods
+- Spring AOP `@Around` advice dispatches: flag ON → EE method; flag OFF → superclass (CE-Compatible/CE)
+- For reactive methods: aspect uses `flatMap` on the flag check Mono
+- For synchronous methods: requires `organizationId` parameter; reads from in-memory org cache
+- New flags: add to `FeatureFlagEnum` in `appsmith-interfaces`
+- Flag naming: `release_*` (rollout), `license_*` (paid), `rollout_*` (gradual), `ab_*` (experiment)
+
+## Custom Annotations
+
+| Annotation | Purpose |
+|------------|---------|
+| `@FeatureFlagged` | Controls method execution via feature flag + AOP |
+| `@Encrypted` | Marks fields for at-rest encryption |
+| `@Cache` / `@CacheEvict` | Reactive method result caching / eviction |
+| `@DistributedLock` | Distributed lock with TTL (default 5 min) |
+| `@RateLimit` | Rate-limits API endpoints |
+
+## Build Commands
+
+```bash
+cd app/server && mvn spotless:apply                    # Format code
+cd app/server && mvn spotless:check                    # Check formatting only
+cd app/server && ./build.sh -DskipTests                # Build without tests
+cd app/server && ./build.sh -DskipTests -T 8           # Build without tests (8 threads)
+```
diff --git a/.cursor/rules/bug-fix-verification.mdc b/.cursor/rules/bug-fix-verification.mdc
new file mode 100644
index 000000000000..06ca61394b8c
--- /dev/null
+++ b/.cursor/rules/bug-fix-verification.mdc
@@ -0,0 +1,57 @@
+---
+description: Checklist for fixing bugs, debugging issues, and verifying bug fixes
+globs:
+alwaysApply: false
+---
+# Bug Fix Workflow (TDD Approach)
+
+## 1. Understand
+
+- Reproduce the issue locally and understand the bug report
+- Identify root cause through code exploration — fix the cause, not symptoms
+- Check if there's a related issue/ticket to reference
+
+## 2. Write Failing Test(s)
+
+Write test(s) that demonstrate the bug before writing any fix code.
+- Server: add test in the relevant `*Test.java` class
+- Client: add test in the relevant `*.test.ts(x)` file
+- Test both CE and EE paths if the bug touches feature-flagged code
+
+## 3. Verify RED
+
+Run the test(s) and confirm they **FAIL**:
+```bash
+# Server
+cd app/server && source envs/test.env.example && mvn test -pl appsmith-server -Dtest=ClassName
+
+# Client
+cd app/client && yarn test:jest -- --testPathPattern=<pattern>
+```
+
+If the test passes without any fix, it does not cover the bug. Rewrite the test.
+
+## 4. Implement Fix
+
+- Address the root cause with minimal, focused changes
+- Follow the CE-EE pattern if the fix touches extensible components
+- No hardcoded values, no debug logging (`console.log`, `System.out.println`)
+- Use safe property access (optional chaining or lodash/get for nested objects)
+- Handle edge cases and null/undefined gracefully
+
+## 5. Verify GREEN
+
+Run the same test(s) and confirm they now **PASS**. Use the same commands from step 3.
+
+## 6. Sanity Check
+
+Run closely related tests to catch obvious regressions. Do NOT run the full test suite locally — that's what CI is for.
+- Find test classes in the same package/module as the changed code
+- Run those specific tests to verify nothing adjacent broke
+- Full regression is validated by CI after push
+
+## Before Committing
+
+- Formatting handled automatically by Husky pre-commit hooks
+- PR title: `fix(scope): description`
+- Reference the issue/ticket in PR description
diff --git a/.cursor/rules/client-unit-tests.mdc b/.cursor/rules/client-unit-tests.mdc
new file mode 100644
index 000000000000..901230788dde
--- /dev/null
+++ b/.cursor/rules/client-unit-tests.mdc
@@ -0,0 +1,149 @@
+---
+description:
+globs: app/client/src/**/*.test.ts,app/client/src/**/*.test.tsx
+alwaysApply: false
+---
+# Client Unit Test Conventions (Jest)
+
+## Framework
+
+- Jest 29 + React Testing Library (no Enzyme, no snapshot testing)
+- `@testing-library/react` for rendering/querying
+- `@testing-library/react` also provides `renderHook` for hook testing
+- `@testing-library/user-event` for user interaction simulation
+- `@testing-library/jest-dom` for DOM matchers
+- MSW (Mock Service Worker) for API mocking
+- `redux-mock-store` for Redux store mocking
+- Test timeout: 9000ms
+
+## Running Tests
+
+```bash
+cd app/client && yarn test:unit                         # All unit tests with coverage
+cd app/client && yarn test:jest -- --testPathPattern=<pattern>  # Specific tests (watch mode)
+```
+
+## Test Setup (Automatic)
+
+Configured in `test/setup.ts`:
+- MSW server starts `beforeAll`, resets handlers `afterEach`, closes `afterAll`
+- Polyfills: `crypto`, `TextDecoder`, `ReadableStream`, `structuredClone`
+- Mocks: `IntersectionObserver`, `ResizeObserver`, `scrollTo`
+
+## Test Patterns
+
+### Component test (with Redux)
+
+```typescript
+import { render, screen } from "test/testUtils";
+
+describe("MyComponent", () => {
+  it("renders correctly with given props", () => {
+    render(<MyComponent label="test" />, {
+      initialState: store.getState(),
+      url: "/app/page-123",
+    });
+
+    expect(screen.getByText("test")).toBeInTheDocument();
+  });
+});
+```
+
+The custom `render` from `test/testUtils` wraps components in `<BrowserRouter>`, `<Provider store>`, and `<ThemeProvider>`.
+
+### Component test (simple, no Redux)
+
+```typescript
+import { render, screen } from "@testing-library/react";
+
+it("renders label", () => {
+  render(<Button label="Click me" />);
+  expect(screen.getByText("Click me")).toBeInTheDocument();
+});
+```
+
+### Hook test
+
+```typescript
+import { renderHook, act } from "@testing-library/react";
+
+it("returns updated value", () => {
+  const { result } = renderHook(() => useMyHook(initialValue));
+
+  act(() => { result.current.update(newValue); });
+
+  expect(result.current.value).toBe(newValue);
+});
+```
+
+### Saga test (generator stepping)
+
+```typescript
+import { runSaga } from "redux-saga";
+
+it("dispatches success on valid input", async () => {
+  const dispatched: any[] = [];
+  await runSaga(
+    { dispatch: (action) => dispatched.push(action), getState: () => mockState },
+    mySaga,
+    { type: ReduxActionTypes.TRIGGER, payload: input },
+  ).toPromise();
+
+  expect(dispatched).toContainEqual({ type: ReduxActionTypes.SUCCESS, payload: expected });
+});
+```
+
+### Parameterized test
+
+```typescript
+test.each([
+  ["input1", "expected1"],
+  ["input2", "expected2"],
+])("converts %s to %s", (input, expected) => {
+  expect(transform(input)).toBe(expected);
+});
+```
+
+### Async assertions
+
+```typescript
+import { waitFor } from "@testing-library/react";
+
+await waitFor(() => {
+  expect(screen.getByText("loaded")).toBeInTheDocument();
+});
+```
+
+## Mocking Patterns
+
+### Module mock with partial override
+
+```typescript
+jest.mock("ee/utils/someUtil", () => ({
+  ...jest.requireActual("ee/utils/someUtil"),
+  specificFunction: jest.fn().mockReturnValue(mockValue),
+}));
+```
+
+### MSW API mock
+
+```typescript
+import { rest } from "msw";
+import { server } from "test/__mocks__/server";
+
+beforeEach(() => {
+  server.use(
+    rest.get("/api/v1/resource/:id", (req, res, ctx) =>
+      res(ctx.json({ responseMeta: { status: 200 }, data: mockData })),
+    ),
+  );
+});
+```
+
+## Key Conventions
+
+- Always import from `"ee/..."` in tests too — never from `"ce/"` directly
+- Use `test/testUtils` `render` for Redux-connected components; `@testing-library/react` for pure components
+- Test factories in `test/factories/` for deterministic widget DSL data
+- Callback mocking: `jest.fn()`, verify with `toHaveBeenCalledWith(...)`
+- Assertions: `expect(x).toEqual(y)` for deep equality, `expect(x).toBe(y)` for primitives
diff --git a/.cursor/rules/commit-conventions.mdc b/.cursor/rules/commit-conventions.mdc
new file mode 100644
index 000000000000..5e9356514334
--- /dev/null
+++ b/.cursor/rules/commit-conventions.mdc
@@ -0,0 +1,31 @@
+---
+description:
+globs:
+alwaysApply: true
+---
+# Commit & PR Conventions
+
+## PR Title Format (Conventional Commits)
+
+`type(scope): description`
+
+**Types:** feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert
+
+**Examples:**
+- `feat(widgets): add new table widget capabilities`
+- `fix(auth): resolve login redirect issue`
+- `refactor(api): simplify error handling logic`
+
+## Commit Message Style
+
+- Use descriptive messages with issue reference when applicable
+- Verb-prefixed: "Add ...", "Fix ...", "Update ...", "Remove ..."
+
+## Pre-commit Checks (Automatic via Husky)
+
+When server files are staged → `mvn spotless:apply` runs automatically
+When client files are staged → `eslint --fix --cache` + `prettier --write --cache` run via lint-staged
+All staged files → `gitleaks` secret scanning runs automatically
+Pre-commit checks are skipped for merge commits.
+
+Do not manually run formatting before commit — Husky handles it.
diff --git a/.cursor/rules/commit/semantic-pr-validator.mdc b/.cursor/rules/commit/semantic-pr-validator.mdc
deleted file mode 100644
index dc61687eaadc..000000000000
--- a/.cursor/rules/commit/semantic-pr-validator.mdc
+++ /dev/null
@@ -1,174 +0,0 @@
----
-description: 
-globs: 
-alwaysApply: true
----
-# Semantic PR Validator
-
-```yaml
-name: Semantic PR Validator
-description: Validates that PR titles follow the Conventional Commits specification
-author: Cursor AI
-version: 1.0.0
-tags:
-  - git
-  - pull-request
-  - semantic
-  - conventional-commits
-activation:
-  always: true
-  event:
-    - pull_request
-    - pull_request_title_edit
-    - command
-triggers:
-  - pull_request.created
-  - pull_request.edited
-  - command: "validate_pr_title"
-```
-
-## Rule Definition
-
-This rule ensures that pull request titles follow the [Conventional Commits](mdc:https:/www.conventionalcommits.org) specification.
-
-## Validation Logic
-
-```javascript
-// Function to validate PR titles against Conventional Commits spec
-function validatePRTitle(title) {
-  // Regular expression for conventional commits format
-  const conventionalCommitRegex = /^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\([a-z0-9-_]+\))?(!)?: [a-z0-9].+$/i;
-  
-  if (!conventionalCommitRegex.test(title)) {
-    return {
-      valid: false,
-      errors: [
-        "PR title doesn't follow the Conventional Commits format: type(scope): description",
-        "Example valid titles:",
-        "- feat(widget): add new table component",
-        "- fix: resolve login issue",
-        "- docs(readme): update installation instructions"
-      ]
-    };
-  }
-  
-  // Check for empty scope in parentheses
-  if (title.includes('()')) {
-    return {
-      valid: false,
-      errors: [
-        "Empty scope provided. Either include a scope value or remove the parentheses."
-      ]
-    };
-  }
-  
-  // Extract parts
-  const match = title.match(/^([a-z]+)(?:\(([a-z0-9-_]+)\))?(!)?:/i);
-  
-  if (!match || !match[1]) {
-    return {
-      valid: false,
-      errors: [
-        "Failed to parse PR title format. Please follow the pattern: type(scope): description"
-      ]
-    };
-  }
-  
-  const type = match[1].toLowerCase();
-  
-  // Validate type
-  const validTypes = ["feat", "fix", "docs", "style", "refactor", 
-                      "perf", "test", "build", "ci", "chore", "revert"];
-  
-  if (!validTypes.includes(type)) {
-    return {
-      valid: false,
-      errors: [
-        `Invalid type "${type}". Valid types are: ${validTypes.join(', ')}`
-      ]
-    };
-  }
-  
-  return { valid: true };
-}
-
-// Triggered when a PR is created or the title is changed
-function onPRTitleChange(prTitle) {
-  const validation = validatePRTitle(prTitle);
-  
-  if (!validation.valid) {
-    return {
-      status: "failure",
-      message: "PR title doesn't follow Conventional Commits format",
-      details: validation.errors.join('\n'),
-      suggestions: [
-        {
-          label: "Fix PR title format",
-          description: "Update title to follow type(scope): description format"
-        }
-      ]
-    };
-  }
-  
-  return {
-    status: "success",
-    message: "PR title follows Conventional Commits format"
-  };
-}
-
-// Run on activation
-function activate(context) {
-  // Register event handlers
-  context.on('pull_request.created', (event) => {
-    const prTitle = event.pull_request.title;
-    return onPRTitleChange(prTitle);
-  });
-  
-  context.on('pull_request.edited', (event) => {
-    const prTitle = event.pull_request.title;
-    return onPRTitleChange(prTitle);
-  });
-  
-  context.registerCommand('validate_pr_title', (args) => {
-    const prTitle = args.title || context.currentPR?.title;
-    if (!prTitle) {
-      return {
-        status: "error",
-        message: "No PR title provided"
-      };
-    }
-    return onPRTitleChange(prTitle);
-  });
-}
-
-// Export the functions
-module.exports = {
-  activate,
-  onPRTitleChange,
-  validatePRTitle
-};
-```
-
-## When It Runs
-
-This rule automatically runs in the following scenarios:
-- When a new pull request is created
-- When a pull request title is edited
-- When a developer asks for validation via Cursor command: `validate_pr_title`
-
-## Usage Example
-
-To validate a PR title before submitting:
-
-1. Create a branch and make your changes
-2. Prepare to create a PR
-3. Use the command: `validate_pr_title` in Cursor
-4. Cursor will check your title and suggest corrections if needed
-
-## Examples of Valid PR Titles
-
-- `feat(widgets): add new table widget capabilities`
-- `fix(auth): resolve login redirect issue`
-- `docs: update README with setup instructions`
-- `refactor(api): simplify error handling logic`
-- `chore: update dependencies to latest versions` 
\ No newline at end of file
diff --git a/.cursor/rules/cypress-tests.mdc b/.cursor/rules/cypress-tests.mdc
new file mode 100644
index 000000000000..c03dd92df5cf
--- /dev/null
+++ b/.cursor/rules/cypress-tests.mdc
@@ -0,0 +1,149 @@
+---
+description:
+globs: app/client/cypress/**/*.ts,app/client/cypress/**/*.js
+alwaysApply: false
+---
+# Cypress E2E Test Conventions
+
+## Framework
+
+- Cypress 13.13.0 with `testIsolation: false` (tests share state within a spec)
+- Plugins: `@cypress/grep` (tag filtering), `cypress-real-events`, `cypress-network-idle`, `cypress-xpath`, `cypress-file-upload`
+- Viewport: 1400x1200
+- Timeouts: `defaultCommandTimeout: 30000`, `requestTimeout/responseTimeout: 60000`
+
+## Running Tests
+
+```bash
+cd app/client && yarn test                              # E2E tests (against dev.appsmith.com)
+cd app/client && npx cypress run --spec <spec-path>     # Specific spec file
+cd app/client && npx cypress open                       # Interactive mode
+```
+
+## Page Object Pattern (Mandatory)
+
+All tests import page objects from `ObjectsCore.ts` — do NOT use raw `cy.get()` for common operations:
+
+```typescript
+import {
+  agHelper,
+  locators,
+  dataSources,
+  deployMode,
+  homePage,
+  jsEditor,
+  propPane,
+} from "../../../../support/Objects/ObjectsCore";
+```
+
+### Key page objects
+
+| Object | Purpose |
+|--------|---------|
+| `agHelper` | Central utility — clicks, assertions, DSL loading, waits |
+| `locators` | Centralized CSS selectors |
+| `dataSources` | Datasource CRUD operations |
+| `deployMode` | Publish app and navigate deployed view |
+| `homePage` | Workspace and app management |
+| `jsEditor` | JS object creation and editing |
+| `propPane` | Property pane interactions |
+
+### Common agHelper methods
+
+| Method | Purpose |
+|--------|---------|
+| `agHelper.AddDsl("dslName")` | Load widget layout fixture via API |
+| `agHelper.GetNClick(selector, index, force)` | Find & click |
+| `agHelper.AssertContains(text)` | Assert page text |
+| `agHelper.AssertElementVisibility(sel)` | Visibility assertion |
+| `agHelper.AssertElementAbsence(sel)` | Absence assertion |
+| `agHelper.ValidateToastMessage(msg)` | Toast check |
+| `deployMode.DeployApp()` | Publish and switch to deployed view |
+| `deployMode.NavigateBacktoEditor()` | Return to edit mode |
+
+## Selector Strategy
+
+Three tiers, in order of preference:
+
+1. **`t--` CSS classes** (dominant): `className="t--application-publish-btn"`
+   - Auto-generated: `.t--draggable-{widgetType}` (edit), `.t--widget-{widgetName}` (deployed)
+2. **`data-testid`** (growing): `data-testid="t--git-connect-next"`
+3. **`data-widgetname-cy`** (widget-specific): `data-widgetname-cy={props.widgetName}`
+
+Selectors centralized in `cypress/locators/` (44 files) plus `CommonLocators.ts` (300+ selectors).
+
+## Test File Conventions
+
+### Naming
+
+- TypeScript (preferred): `FeatureName_Spec.ts` (capital S in Spec)
+- Legacy JavaScript: `WidgetName_spec.js`
+- Bug tests include numbers: `Bug14987_spec.js`, `DS_Bug26941_Spec.ts`
+
+### Structure (testIsolation: false)
+
+Tests within a spec share state. Use numbered `it` blocks for sequential steps:
+
+```typescript
+describe(
+  "Feature Name",
+  { tags: ["@tag.Widget", "@tag.Input"] },
+  function () {
+    it("1. Setup and verify initial state", function () { ... });
+    it("2. Perform action and verify result", function () { ... });
+    it("3. Cleanup", function () { ... });
+  },
+);
+```
+
+Tags follow `@tag.Category` pattern for `@cypress/grep` filtering.
+
+## Setup / Teardown
+
+### Global (in `cypress/support/e2e.js`)
+
+- `before()` — API-based login via `cy.LoginFromAPI()`, create workspace + app
+- `beforeEach()` — Re-initialize localStorage, register ~116 route intercepts
+- `after()` — Delete app and workspace via API
+
+### Per-spec
+
+- `before()` — Load DSL fixtures: `agHelper.AddDsl("chartDsl")`
+- Final `it` block — Delete created entities
+
+## API Intercept Pattern
+
+Route intercepts are spy-style (not stubs). Registered in bulk via `startServerAndRoutes`:
+
+```typescript
+cy.intercept("PUT", "/api/v1/themes/applications/*").as("updateTheme");
+cy.intercept("POST", "/api/v1/datasources/test").as("testDatasource");
+```
+
+Wait on aliases for synchronization: `cy.wait("@importNewApplication")`
+
+No `cy.intercept({ fixture: '...' })` stubbing — all tests run against a real backend.
+
+## DSL Fixtures
+
+Widget layouts defined as JSON in `cypress/fixtures/`. Loaded via `agHelper.AddDsl()` which injects via `PUT /api/v1/layouts/`:
+
+```json
+{
+  "dsl": {
+    "widgetName": "MainContainer",
+    "type": "CANVAS_WIDGET",
+    "children": [
+      { "widgetName": "Input1", "type": "INPUT_WIDGET_V2" }
+    ]
+  }
+}
+```
+
+## Key Conventions
+
+- API-based setup/teardown — login, workspace creation, cleanup all via API, not UI
+- No test isolation — sequential numbered `it` blocks within a spec
+- Page objects over raw commands — use `agHelper`, `dataSources`, etc.
+- Selectors: prefer `t--` classes, centralize in `locators/`
+- Tags for categorization: `@tag.Widget`, `@tag.Datasource`, `@tag.Git`, etc.
diff --git a/.cursor/rules/feature-verification.mdc b/.cursor/rules/feature-verification.mdc
new file mode 100644
index 000000000000..bbb70f6b072d
--- /dev/null
+++ b/.cursor/rules/feature-verification.mdc
@@ -0,0 +1,53 @@
+---
+description: Checklist for implementing new features, adding functionality, and feature development
+globs:
+alwaysApply: false
+---
+# Feature Implementation Checklist
+
+## Planning
+
+- [ ] Understand requirements and acceptance criteria
+- [ ] Design the implementation approach before writing code
+- [ ] Identify which components need the CE → CE-Compatible → EE pattern
+
+## Implementation
+
+### Backend (if applicable)
+- [ ] Create full CE → CE-Compatible → EE chain for new services/controllers/repositories
+- [ ] `@Service` only on the final `*Impl` class
+- [ ] New API endpoints: `Mono<ResponseDTO<T>>` return type, `@JsonView(Views.Public.class)`
+- [ ] Add URL path constant to `UrlCE.java`
+- [ ] Error handling via `AppsmithException(AppsmithError.XXX)`
+- [ ] Add `@FeatureFlagged` if the feature should be gated behind a flag
+- [ ] New feature flag? Add to `FeatureFlagEnum` in `appsmith-interfaces`
+
+### Frontend (if applicable)
+- [ ] Create `ce/` implementation + `ee/` re-export stub for new modules
+- [ ] Import from `"ee/..."` everywhere — never `"ce/"` directly
+- [ ] Follow Redux handler-map pattern for new state (not switch-case)
+- [ ] Action types: `_INIT`, `_SUCCESS`, `_ERROR` naming convention
+- [ ] New feature flag? Add to `FeatureFlag` in `ce/entities/FeatureFlag.ts` + use `useFeatureFlag()`
+- [ ] Styled-components for new UI; design tokens via `--ads-v2-*`
+- [ ] JSX props alphabetically sorted (enforced by ESLint)
+- [ ] Named functions in `useEffect` (enforced by `@appsmith/named-use-effect`)
+
+## Testing
+
+- [ ] Write unit tests covering the new functionality
+- [ ] Test both feature-flag-on and feature-flag-off paths if applicable
+- [ ] Server test: `cd app/server && source envs/test.env.example && mvn test -pl appsmith-server -Dtest=ClassName`
+- [ ] Client test: `cd app/client && yarn test:unit`
+- [ ] Consider edge cases: empty state, error state, large data, concurrent access
+
+## Accessibility (for UI features)
+
+- [ ] ARIA attributes on interactive elements
+- [ ] Keyboard navigation support
+- [ ] Semantic HTML elements where appropriate
+
+## Before Committing
+
+- [ ] Formatting handled automatically by Husky pre-commit hooks
+- [ ] PR title: `feat(scope): description`
+- [ ] Documentation updated if the feature has user-facing changes
diff --git a/.cursor/rules/frontend-react.mdc b/.cursor/rules/frontend-react.mdc
new file mode 100644
index 000000000000..fe45046c3cc3
--- /dev/null
+++ b/.cursor/rules/frontend-react.mdc
@@ -0,0 +1,136 @@
+---
+description:
+globs: app/client/src/**/*.ts,app/client/src/**/*.tsx
+alwaysApply: false
+---
+# React / TypeScript Frontend Conventions
+
+## Tech Stack
+
+- React 18, TypeScript (strict mode), Redux + Redux-Saga, styled-components
+- Build: Webpack, Yarn 3 (Berry) with workspaces
+- Linting: ESLint (Airbnb-based) + Prettier (80 cols, 2-space, double quotes, trailing commas)
+- Node: ^20.11.1
+
+## CE-EE Import Pattern (Critical)
+
+- `app/client/src/ce/` — real Community Edition implementations
+- `app/client/src/ee/` — re-export stubs in CE: `export * from "ce/..."`
+- **Always import from `"ee/..."`, never from `"ce/"` directly** (enforced by ESLint)
+- TypeScript path alias: `"ee/*": ["ee/*"]` in `tsconfig.path.json`
+- When creating new modules: create `ce/` implementation + matching `ee/` re-export stub
+- Frontend feature flags: `useFeatureFlag(flagName)` hook reads from Redux, with dev override support via `window.overrideFeatureFlag()`
+
+## Component Conventions
+
+- Functional components with hooks exclusively (class components only as legacy base classes)
+- Props typing: `interface` for extendable shapes (preferred), `type` for unions/intersections
+- `@typescript-eslint/no-explicit-any: "error"` — `any` is banned
+- `import type` enforced for type-only imports (`@typescript-eslint/consistent-type-imports`)
+
+## Styling
+
+- **styled-components**: primary approach throughout the app
+- **CSS Modules** (`.module.css`): secondary, used in WDS widgets and CustomWidgetBuilder
+- Design tokens: `--ads-v2-*` prefix (design system), `--color-*` / `--border-*` (WDS)
+- Three design system layers:
+  - `@appsmith/ads` — 30+ styled-components (primary)
+  - Legacy `designSystems/appsmith/` — wraps BlueprintJS
+  - `@appsmith/wds` — CSS Modules for widgets
+- No Tailwind
+
+## State Management (Redux + Redux-Saga)
+
+### Reducers — handler-map pattern (not switch-case, not Redux Toolkit)
+
+```typescript
+const handlers = {
+  [ReduxActionTypes.FETCH_DATA]: (state) => ({ ...state, isLoading: true }),
+  [ReduxActionTypes.FETCH_DATA_SUCCESS]: (state, action) => ({
+    ...state, isLoading: false, data: action.payload,
+  }),
+};
+export default createReducer(initialState, handlers);
+```
+
+### Action types — string constants
+
+All defined in `ce/constants/ReduxActionConstants.tsx`, merged into `ReduxActionTypes` and `ReduxActionErrorTypes`. Naming: `_INIT` for trigger, `_SUCCESS` for success, `_ERROR` for error.
+
+### Action creators — plain functions
+
+```typescript
+export const fetchData = (id: string) => ({
+  type: ReduxActionTypes.FETCH_DATA_INIT,
+  payload: { id },
+});
+```
+
+### Sagas — takeLatest/takeEvery/debounce
+
+```typescript
+export default function* dataSagas() {
+  yield all([
+    takeLatest(ReduxActionTypes.FETCH_DATA_INIT, fetchDataSaga),
+  ]);
+}
+```
+
+Worker sagas use try/catch with `call`/`put`/`select`.
+
+### Selectors — plain functions + reselect's createSelector
+
+```typescript
+export const getData = (state: DefaultRootState) => state.entities.data;
+export const getDerivedData = createSelector(getData, getOther, (data, other) => { ... });
+```
+
+## API Calls
+
+- **Axios** exclusively (no fetch API)
+- Base URL: `/api/` (relative, same origin)
+- Response envelope: `{ responseMeta: { status, success, error? }, data: T }` via `ApiResponse<T>`
+- Two patterns coexist:
+  - Legacy: class-based extending `Api` base class with static methods
+  - Newer: functional factory via `apiFactory()` in `api/core/`
+- Error handling: chain-of-responsibility via axios interceptors (401, 404, 413, 502, timeout, offline)
+
+## File & Folder Conventions
+
+| Context | Convention |
+|---------|-----------|
+| Components / feature dirs | PascalCase (`ModalComponent.tsx`, `ConnectModal/`) |
+| Utility dirs | camelCase (`utils/`, `hooks/`, `constants/`) |
+| Barrel exports | `index.ts` / `index.tsx` |
+| Test files | `<name>.test.ts(x)` in `__tests__/` or adjacent |
+
+Structure: hybrid by-type at top level + by-feature for domains:
+- Top-level: `actions/`, `reducers/`, `sagas/`, `selectors/`, `api/`, `hooks/`, `utils/`
+- Feature modules (e.g., `git/`, `IDE/`): self-contained with own `components/`, `hooks/`, `store/`
+- `ce/` and `ee/` mirror the by-type structure
+
+## ESLint Rules (Notable)
+
+- `no-console: "error"`, `no-debugger: "error"`
+- `react/jsx-sort-props: "error"` — JSX props must be alphabetically sorted
+- `@appsmith/named-use-effect` — `useEffect` must receive named functions, not arrow functions
+- `@appsmith/object-keys` — use `objectKeys()` instead of `Object.keys()`
+- Restricted imports: `**/ce/*` (must use `ee/`), `codemirror`, `lottie-web`, `@uppy/*`
+- `react-compiler/react-compiler: "warn"` — React compiler compatibility
+
+## Custom Hooks
+
+- 195+ hook files across the codebase
+- General-purpose in `utils/hooks/`; domain hooks in feature directories
+- All hooks use TypeScript generics where appropriate
+- Named function convention enforced by `@appsmith/named-use-effect`
+
+## Build & Verify Commands
+
+```bash
+cd app/client && yarn lint              # ESLint
+cd app/client && yarn prettier          # Prettier check
+cd app/client && yarn test:unit         # Jest unit tests
+cd app/client && yarn check-types       # TypeScript type-check
+cd app/client && yarn start             # Dev server
+```
diff --git a/.cursor/rules/index.mdc b/.cursor/rules/index.mdc
deleted file mode 100644
index c09ccef5f156..000000000000
--- a/.cursor/rules/index.mdc
+++ /dev/null
@@ -1,136 +0,0 @@
----
-description: 
-globs: 
-alwaysApply: true
----
- # Appsmith Cursor Rules
-
-```yaml
-name: Appsmith Cursor Rules
-description: A comprehensive set of rules for Cursor AI to enhance development for Appsmith
-author: Cursor AI
-version: 1.0.0
-tags:
-  - appsmith
-  - development
-  - quality
-  - verification
-activation:
-  always: true
-  event:
-    - pull_request
-    - file_change
-    - command
-triggers:
-  - pull_request.created
-  - pull_request.updated
-  - file.created
-  - file.modified
-  - command: "cursor_help"
-```
-
-## Overview
-
-This is the main entry point for Cursor AI rules for the Appsmith codebase. These rules help enforce consistent coding standards, verify bug fixes and features, generate appropriate tests, and optimize performance.
-
-## Available Rules
-
-### 1. [Semantic PR Validator](mdc:semantic_pr_validator.mdc)
-
-Ensures pull request titles follow the Conventional Commits specification.
-
-```javascript
-// Example usage
-const semanticPR = require('./semantic_pr_validator');
-const validation = semanticPR.onPRTitleChange('feat(widgets): add new table component');
-console.log(validation.status); // 'success'
-```
-
-### 2. [Bug Fix Verifier](mdc:bug_fix_verifier.mdc)
-
-Guides developers through the proper steps to fix bugs and verifies that fixes meet quality standards.
-
-```javascript
-// Example usage
-const bugFixVerifier = require('./bug_fix_verifier');
-const verification = bugFixVerifier.verifyBugFix(changedFiles, testFiles, issueDetails);
-console.log(verification.score); // The verification score
-```
-
-### 3. [Test Generator](mdc:test_generator.mdc)
-
-Analyzes code changes and generates appropriate test cases to ensure proper test coverage.
-
-```javascript
-// Example usage
-const testGenerator = require('./test_generator');
-const testPlan = testGenerator.generateTests(changedFiles, codebase);
-console.log(testPlan.summary); // 'Generated X test plans'
-```
-
-### 4. [Performance Optimizer](mdc:performance_optimizer.mdc)
-
-Identifies performance bottlenecks in code and suggests optimizations to improve efficiency.
-
-```javascript
-// Example usage
-const performanceOptimizer = require('./performance_optimizer');
-const analysis = performanceOptimizer.analyzePerformance(changedFiles, codebase);
-console.log(analysis.score); // The performance score
-```
-
-### 5. [Feature Implementation Validator](mdc:feature_implementation_validator.mdc)
-
-Ensures new feature implementations meet all requirements, follow best practices, and include appropriate tests.
-
-```javascript
-// Example usage
-const featureValidator = require('./feature_implementation_validator');
-const validation = featureValidator.validateFeature(
-  implementationFiles, 
-  codebase,
-  pullRequest
-);
-console.log(validation.score); // The feature implementation score
-```
-
-## Integration
-
-These rules are automatically integrated into Cursor AI when working with the Appsmith codebase. They will be triggered based on context and can also be manually invoked through commands.
-
-## Command Examples
-
-- `validate_pr_title` - Check if a PR title follows conventional commits format
-- `verify_bug_fix --pullRequest=123` - Verify a bug fix implementation
-- `generate_tests --file=src/utils/helpers.js` - Generate tests for a specific file
-- `optimize_performance --file=src/components/Table.tsx` - Analyze and optimize performance 
-- `validate_feature --pullRequest=123` - Validate a feature implementation
-
-## Configuration
-
-The behavior of these rules can be customized in the `.cursor/settings.json` file. For example:
-
-```json
-{
-  "development": {
-    "gitWorkflow": {
-      "semanticPR": {
-        "enabled": true,
-        "titleFormat": "type(scope): description",
-        "validTypes": [
-          "feat", "fix", "docs", "style", "refactor", 
-          "perf", "test", "build", "ci", "chore", "revert"
-        ]
-      }
-    }
-  }
-}
-```
-
-## Documentation
-
-For more detailed information about each rule and how to use it effectively, please refer to the individual rule files linked above.
-
-## Activation
-
-To activate all rules, run `cursor_help` in the command palette. This will display available commands and provide guidance on using the rules for your specific task.
\ No newline at end of file
diff --git a/.cursor/rules/project-conventions.mdc b/.cursor/rules/project-conventions.mdc
new file mode 100644
index 000000000000..62690d44cb00
--- /dev/null
+++ b/.cursor/rules/project-conventions.mdc
@@ -0,0 +1,89 @@
+---
+description:
+globs:
+alwaysApply: true
+---
+# Appsmith Project Conventions
+
+## Codebase Structure
+
+- **Frontend**: `app/client/` — React 18, TypeScript, Redux + Redux-Saga, styled-components
+- **Backend**: `app/server/` — Java 25, Spring Boot 3.5, Spring WebFlux (reactive), MongoDB, Maven
+- **E2E Tests**: `app/client/cypress/` — Cypress 13
+- **CI/CD**: `.github/workflows/`
+- **Infrastructure**: `deploy/`
+
+## CE-EE Architecture (Critical)
+
+Appsmith has a Community Edition (CE) and Enterprise Edition (EE). This repo is CE. EE is a private superset that syncs from CE hourly.
+
+### Three-Layer Model
+
+Every extensible service/component follows: **CE → CE-Compatible → EE**
+
+- **CE layer** (`*.ce` package / `src/ce/` directory): Base open-source implementation. Contains all core logic.
+- **CE-Compatible layer** (`*.ce_compatible` package): Graceful degradation layer. When an enterprise license expires, resources created with paid features remain accessible in read-only mode through this layer. In CE repo, these are empty pass-throughs.
+- **EE layer** (parent package / `src/ee/` directory): Enterprise overrides. Methods annotated with `@FeatureFlagged`. In CE repo, EE files are thin stubs that re-export from CE.
+
+### Feature Flag Dispatch (Spring AOP)
+
+`@FeatureFlagged(featureFlagName = FeatureFlagEnum.XXX)` on EE methods. The `FeatureFlaggedMethodInvokerAspect` (`@Around` advice) checks the flag:
+- **Flag ON** → executes the EE method
+- **Flag OFF** → reflectively invokes the superclass (CE-Compatible) method
+- If CE-Compatible doesn't override → falls through to CE base
+
+Flags are evaluated per-organization (cached) with user-level fallback (Flagsmith). Organization flags take precedence.
+
+### Backend CE-EE Pattern
+
+```text
+Interface: ServiceCE → ServiceCECompatible → Service
+Impl:      ServiceCEImpl → ServiceCECompatibleImpl → ServiceImpl (@Service)
+```
+
+- `@Service` annotation on CE-Compatible and final `*Impl` classes (not on CE base classes)
+- Constructor-based DI exclusively (no field injection)
+- CE impl holds all business logic; final impl is a pass-through in CE repo
+- This pattern applies to services, repositories, controllers, solutions, domains, DTOs
+
+### Frontend CE-EE Pattern
+
+- `app/client/src/ce/` — real implementations (306+ files)
+- `app/client/src/ee/` — re-export stubs in CE: `export * from "ce/..."`
+- **Always import from `"ee/..."`, never from `"ce/"` directly** (enforced by ESLint restricted-imports)
+- TypeScript path alias in `tsconfig.path.json`: `"ee/*": ["ee/*"]`
+- Frontend feature flags: `useFeatureFlag(flagName)` hook from `"utils/hooks/useFeatureFlag"`
+
+### When Creating New Features
+
+- New service? Create full CE → CE-Compatible → EE chain
+- New frontend module? Create `ce/` implementation + `ee/` re-export stub
+- New feature flag? Add to `FeatureFlagEnum` (server) and `FeatureFlag` (client)
+- Extension point for EE? Use `protected` methods in CE impl that EE can override
+
+## Git & PR Conventions
+
+- Branch naming: `fix/fix-name`, `feature/feature-name`
+- PR titles: Conventional Commits format — `type(scope): description`
+- Valid types: `feat`, `fix`, `docs`, `style`, `refactor`, `perf`, `test`, `build`, `ci`, `chore`, `revert`
+- Scope is optional but recommended
+
+## Pre-existing Automation
+
+- **Husky pre-commit**: When server files are staged, runs `mvn spotless:apply`. When client files are staged, runs `lint-staged` (eslint --fix --cache + prettier --write --cache). All files get `gitleaks` secret scanning. Skipped for merge commits.
+- **Husky pre-push**: Blocks pushing `app/client/src/ee` files to CE remote
+
+## Build & Verify Commands
+
+```bash
+# Server
+cd app/server && mvn spotless:apply          # Format Java code
+cd app/server && mvn spotless:check          # Check formatting
+cd app/server && ./build.sh -DskipTests      # Build without tests
+
+# Client
+cd app/client && yarn lint                   # ESLint check
+cd app/client && yarn prettier               # Prettier check
+cd app/client && yarn test:unit              # Jest unit tests
+cd app/client && yarn check-types            # TypeScript type-check
+```
diff --git a/.cursor/rules/quality/performance-optimizer.mdc b/.cursor/rules/quality/performance-optimizer.mdc
deleted file mode 100644
index 30092e01ab0d..000000000000
--- a/.cursor/rules/quality/performance-optimizer.mdc
+++ /dev/null
@@ -1,358 +0,0 @@
----
-description: 
-globs: 
-alwaysApply: true
----
-# Performance Optimizer
-
-```yaml
-name: Performance Optimizer
-description: Analyzes code for performance issues and suggests improvements
-author: Cursor AI
-version: 1.0.0
-tags:
-  - performance
-  - optimization
-  - analysis
-activation:
-  always: true
-  event:
-    - file_change
-    - pull_request
-    - command
-triggers:
-  - file.modified
-  - pull_request.created
-  - pull_request.updated
-  - command: "optimize_performance"
-```
-
-## Rule Definition
-
-This rule analyzes code changes for potential performance issues and suggests optimizations.
-
-## Performance Analysis Logic
-
-```javascript
-// Main function to analyze code for performance issues
-function analyzePerformance(files, codebase) {
-  const issues = [];
-  const suggestions = [];
-  let score = 100; // Start with perfect score
-  
-  // Process each file
-  for (const file of files) {
-    const fileIssues = findPerformanceIssues(file, codebase);
-    if (fileIssues.length > 0) {
-      issues.push(...fileIssues);
-      
-      // Reduce score based on severity of issues
-      score -= fileIssues.reduce((total, issue) => total + issue.severity, 0);
-      
-      // Generate optimization suggestions
-      const fileSuggestions = generateOptimizationSuggestions(file, fileIssues, codebase);
-      suggestions.push(...fileSuggestions);
-    }
-  }
-  
-  // Ensure score doesn't go below 0
-  score = Math.max(0, score);
-  
-  return {
-    score,
-    issues,
-    suggestions,
-    summary: generatePerformanceSummary(score, issues, suggestions)
-  };
-}
-
-// Find performance issues in a file
-function findPerformanceIssues(file, codebase) {
-  const issues = [];
-  
-  // Check file based on its type
-  if (file.path.includes('.ts') || file.path.includes('.js')) {
-    issues.push(...findJavaScriptPerformanceIssues(file));
-  } else if (file.path.includes('.java')) {
-    issues.push(...findJavaPerformanceIssues(file));
-  } else if (file.path.includes('.css')) {
-    issues.push(...findCssPerformanceIssues(file));
-  }
-  
-  return issues;
-}
-
-// Find performance issues in JavaScript/TypeScript files
-function findJavaScriptPerformanceIssues(file) {
-  const issues = [];
-  const content = file.content;
-  
-  // Check for common JavaScript performance issues
-  
-  // 1. Nested loops with high complexity (O(n²) or worse)
-  if (/for\s*\([^)]*\)\s*\{[^}]*for\s*\([^)]*\)/g.test(content)) {
-    issues.push({
-      type: 'nested_loops',
-      lineNumber: findLineNumber(content, /for\s*\([^)]*\)\s*\{[^}]*for\s*\([^)]*\)/g),
-      description: 'Nested loops detected, which may cause O(n²) time complexity',
-      severity: 8,
-      suggestion: 'Consider refactoring to reduce time complexity, possibly using maps/sets'
-    });
-  }
-  
-  // 2. Large array operations without memoization
-  if (/\.map\(.*\.filter\(|\.filter\(.*\.map\(/g.test(content)) {
-    issues.push({
-      type: 'chained_array_operations',
-      lineNumber: findLineNumber(content, /\.map\(.*\.filter\(|\.filter\(.*\.map\(/g),
-      description: 'Chained array operations may cause performance issues with large datasets',
-      severity: 5,
-      suggestion: 'Consider combining operations or using a different data structure'
-    });
-  }
-  
-  // 3. Frequent DOM manipulations
-  if (/document\.getElement(s?)By|querySelector(All)?/g.test(content) && 
-      content.match(/document\.getElement(s?)By|querySelector(All)?/g).length > 5) {
-    issues.push({
-      type: 'frequent_dom_manipulation',
-      lineNumber: findLineNumber(content, /document\.getElement(s?)By|querySelector(All)?/g),
-      description: 'Frequent DOM manipulations can cause layout thrashing',
-      severity: 7,
-      suggestion: 'Batch DOM manipulations or use DocumentFragment'
-    });
-  }
-  
-  // 4. Memory leaks in event listeners
-  if (/addEventListener\(/g.test(content) && 
-      !/removeEventListener\(/g.test(content)) {
-    issues.push({
-      type: 'potential_memory_leak',
-      lineNumber: findLineNumber(content, /addEventListener\(/g),
-      description: 'Event listener without corresponding removal may cause memory leaks',
-      severity: 6,
-      suggestion: 'Add corresponding removeEventListener calls where appropriate'
-    });
-  }
-  
-  // Add more JavaScript-specific performance checks here
-  
-  return issues;
-}
-
-// Find performance issues in Java files
-function findJavaPerformanceIssues(file) {
-  const issues = [];
-  const content = file.content;
-  
-  // Check for common Java performance issues
-  
-  // 1. Inefficient string concatenation
-  if (/String.*\+= |String.*= .*\+ /g.test(content)) {
-    issues.push({
-      type: 'inefficient_string_concat',
-      lineNumber: findLineNumber(content, /String.*\+= |String.*= .*\+ /g),
-      description: 'Inefficient string concatenation in loops',
-      severity: 4,
-      suggestion: 'Use StringBuilder instead of string concatenation'
-    });
-  }
-  
-  // 2. Unclosed resources
-  if (/new FileInputStream|new Connection/g.test(content) &&
-      !/try\s*\([^)]*\)/g.test(content)) {
-    issues.push({
-      type: 'unclosed_resources',
-      lineNumber: findLineNumber(content, /new FileInputStream|new Connection/g),
-      description: 'Resources may not be properly closed',
-      severity: 7,
-      suggestion: 'Use try-with-resources to ensure proper resource closure'
-    });
-  }
-  
-  // Add more Java-specific performance checks here
-  
-  return issues;
-}
-
-// Find performance issues in CSS files
-function findCssPerformanceIssues(file) {
-  const issues = [];
-  const content = file.content;
-  
-  // Check for common CSS performance issues
-  
-  // 1. Overqualified selectors
-  if (/div\.[a-zA-Z0-9_-]+|ul\.[a-zA-Z0-9_-]+/g.test(content)) {
-    issues.push({
-      type: 'overqualified_selectors',
-      lineNumber: findLineNumber(content, /div\.[a-zA-Z0-9_-]+|ul\.[a-zA-Z0-9_-]+/g),
-      description: 'Overqualified selectors may impact rendering performance',
-      severity: 3,
-      suggestion: 'Use more efficient selectors, avoiding element type with class'
-    });
-  }
-  
-  // 2. Universal selectors
-  if (/\*\s*\{/g.test(content)) {
-    issues.push({
-      type: 'universal_selector',
-      lineNumber: findLineNumber(content, /\*\s*\{/g),
-      description: 'Universal selectors can be very slow, especially in large documents',
-      severity: 5,
-      suggestion: 'Replace universal selectors with more specific ones'
-    });
-  }
-  
-  // Add more CSS-specific performance checks here
-  
-  return issues;
-}
-
-// Find line number for a regex match
-function findLineNumber(content, regex) {
-  const match = content.match(regex);
-  if (!match) return 0;
-  
-  const index = content.indexOf(match[0]);
-  return content.substring(0, index).split('\n').length;
-}
-
-// Generate optimization suggestions based on issues found
-function generateOptimizationSuggestions(file, issues, codebase) {
-  const suggestions = [];
-  
-  for (const issue of issues) {
-    const suggestion = {
-      file: file.path,
-      issue: issue.type,
-      description: issue.suggestion,
-      lineNumber: issue.lineNumber,
-      code: issue.suggestion // This would be actual code in a real implementation
-    };
-    
-    suggestions.push(suggestion);
-  }
-  
-  return suggestions;
-}
-
-// Generate a summary of the performance analysis
-function generatePerformanceSummary(score, issues, suggestions) {
-  const criticalIssues = issues.filter(issue => issue.severity >= 7).length;
-  const majorIssues = issues.filter(issue => issue.severity >= 4 && issue.severity < 7).length;
-  const minorIssues = issues.filter(issue => issue.severity < 4).length;
-  
-  return {
-    score,
-    issues: {
-      total: issues.length,
-      critical: criticalIssues,
-      major: majorIssues,
-      minor: minorIssues
-    },
-    suggestions: suggestions.length,
-    recommendation: getPerformanceRecommendation(score)
-  };
-}
-
-// Get a recommendation based on the performance score
-function getPerformanceRecommendation(score) {
-  if (score >= 90) {
-    return "Code looks good performance-wise. Only minor optimizations possible.";
-  } else if (score >= 70) {
-    return "Some performance issues found. Consider addressing them before deploying.";
-  } else if (score >= 50) {
-    return "Significant performance issues detected. Optimizations strongly recommended.";
-  } else {
-    return "Critical performance issues found. The code may perform poorly in production.";
-  }
-}
-
-// Run on activation
-function activate(context) {
-  // Register event handlers
-  context.on('file.modified', (event) => {
-    const file = context.getFileContent(event.file.path);
-    const codebase = context.getCodebase();
-    return analyzePerformance([file], codebase);
-  });
-  
-  context.on('pull_request.created', (event) => {
-    const files = context.getPullRequestFiles(event.pullRequest.id);
-    const codebase = context.getCodebase();
-    return analyzePerformance(files, codebase);
-  });
-  
-  context.on('pull_request.updated', (event) => {
-    const files = context.getPullRequestFiles(event.pullRequest.id);
-    const codebase = context.getCodebase();
-    return analyzePerformance(files, codebase);
-  });
-  
-  context.registerCommand('optimize_performance', (args) => {
-    const filePath = args.file || context.getCurrentFilePath();
-    if (!filePath) {
-      return {
-        status: "error",
-        message: "No file specified"
-      };
-    }
-    
-    const file = context.getFileContent(filePath);
-    const codebase = context.getCodebase();
-    return analyzePerformance([file], codebase);
-  });
-}
-
-// Export functions
-module.exports = {
-  activate,
-  analyzePerformance,
-  findPerformanceIssues,
-  generateOptimizationSuggestions,
-  generatePerformanceSummary
-};
-```
-
-## When It Runs
-
-This rule can be triggered:
-- When code changes might impact performance
-- When a pull request is created or updated
-- When a developer runs the `optimize_performance` command in Cursor
-- Before deploying to production environments
-
-## Usage Example
-
-1. Make code changes to a file
-2. Run `optimize_performance` in Cursor
-3. Review the performance analysis
-4. Implement the suggested optimizations
-5. Re-run the analysis to confirm improvements
-
-## Performance Optimization Best Practices
-
-### JavaScript/TypeScript
-
-- Avoid nested loops when possible
-- Use appropriate data structures (Map, Set) for lookups
-- Minimize DOM manipulations
-- Use event delegation instead of multiple event listeners
-- Memoize expensive function calls
-- Use requestAnimationFrame for animations
-
-### Java
-
-- Use StringBuilder for string concatenation
-- Use try-with-resources for proper resource management
-- Avoid excessive object creation
-- Choose appropriate collections (ArrayList, HashMap) based on use-case
-- Use primitive types where possible instead of wrapper classes
-
-### CSS
-
-- Avoid universal selectors and deeply nested selectors
-- Minimize the use of expensive properties (box-shadow, border-radius, etc.)
-- Prefer class selectors over tag selectors
-- Use CSS containment where appropriate
diff --git a/.cursor/rules/quality/pre-commit-checks.mdc b/.cursor/rules/quality/pre-commit-checks.mdc
deleted file mode 100644
index 92f2e78a1127..000000000000
--- a/.cursor/rules/quality/pre-commit-checks.mdc
+++ /dev/null
@@ -1,310 +0,0 @@
----
-description: 
-globs: 
-alwaysApply: true
----
- # Pre-Commit Quality Checks
-
-```yaml
-name: Pre-Commit Quality Checks
-description: Runs quality checks similar to GitHub Actions locally before commits
-author: Cursor AI
-version: 1.0.0
-tags:
-  - quality
-  - pre-commit
-  - testing
-  - linting
-activation:
-  always: true
-  events:
-    - pre_commit
-    - command
-triggers:
-  - pre_commit
-  - command: "run_quality_checks"
-```
-
-## Rule Definition
-
-This rule runs the same quality checks locally that would normally run in CI, preventing commits that would fail in the GitHub workflow quality-checks.yml.
-
-## Implementation
-
-```javascript
-const { execSync } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-
-/**
- * Determines which checks to run based on changed files
- * @param {string[]} changedFiles - List of changed files
- * @returns {Object} Object indicating which checks to run
- */
-function determineChecksToRun(changedFiles) {
-  const checks = {
-    serverChecks: false,
-    clientChecks: false,
-  };
-
-  // Check if server files have changed
-  checks.serverChecks = changedFiles.some(file => 
-    file.startsWith('app/server/')
-  );
-
-  // Check if client files have changed
-  checks.clientChecks = changedFiles.some(file => 
-    file.startsWith('app/client/')
-  );
-
-  return checks;
-}
-
-/**
- * Gets a list of changed files in the current git staging area
- * @returns {string[]} List of changed files
- */
-function getChangedFiles() {
-  try {
-    const output = execSync('git diff --cached --name-only', { encoding: 'utf8' });
-    return output.split('\n').filter(Boolean);
-  } catch (error) {
-    console.error('Error getting changed files:', error.message);
-    return [];
-  }
-}
-
-/**
- * Runs client-side quality checks
- * @returns {Object} Results of the checks
- */
-function runClientChecks() {
-  const results = {
-    success: true,
-    errors: [],
-    output: []
-  };
-
-  try {
-    // Run client lint
-    console.log('Running client lint checks...');
-    try {
-      const lintOutput = execSync('cd app/client && yarn lint', { encoding: 'utf8' });
-      results.output.push('✅ Client lint passed');
-    } catch (error) {
-      results.success = false;
-      results.errors.push('Client lint failed');
-      results.output.push(`❌ Client lint failed: ${error.message}`);
-    }
-
-    // Run client unit tests
-    console.log('Running client unit tests...');
-    try {
-      const testOutput = execSync('cd app/client && yarn test', { encoding: 'utf8' });
-      results.output.push('✅ Client unit tests passed');
-    } catch (error) {
-      results.success = false;
-      results.errors.push('Client unit tests failed');
-      results.output.push(`❌ Client unit tests failed: ${error.message}`);
-    }
-
-    // Check for cyclic dependencies
-    console.log('Checking for cyclic dependencies...');
-    try {
-      const cyclicCheckOutput = execSync('cd app/client && yarn check-circular-deps', { encoding: 'utf8' });
-      results.output.push('✅ No cyclic dependencies found');
-    } catch (error) {
-      results.success = false;
-      results.errors.push('Cyclic dependencies check failed');
-      results.output.push(`❌ Cyclic dependencies found: ${error.message}`);
-    }
-
-    // Run prettier check
-    console.log('Running prettier check...');
-    try {
-      const prettierOutput = execSync('cd app/client && yarn prettier', { encoding: 'utf8' });
-      results.output.push('✅ Prettier check passed');
-    } catch (error) {
-      results.success = false;
-      results.errors.push('Prettier check failed');
-      results.output.push(`❌ Prettier check failed: ${error.message}`);
-    }
-  } catch (error) {
-    results.success = false;
-    results.errors.push(`General error in client checks: ${error.message}`);
-  }
-
-  return results;
-}
-
-/**
- * Runs server-side quality checks
- * @returns {Object} Results of the checks
- */
-function runServerChecks() {
-  const results = {
-    success: true,
-    errors: [],
-    output: []
-  };
-
-  try {
-    // Run server unit tests
-    console.log('Running server unit tests...');
-    try {
-      const testOutput = execSync('cd app/server && ./gradlew test', { encoding: 'utf8' });
-      results.output.push('✅ Server unit tests passed');
-    } catch (error) {
-      results.success = false;
-      results.errors.push('Server unit tests failed');
-      results.output.push(`❌ Server unit tests failed: ${error.message}`);
-    }
-
-    // Run server spotless check
-    console.log('Running server spotless check...');
-    try {
-      const spotlessOutput = execSync('cd app/server && ./gradlew spotlessCheck', { encoding: 'utf8' });
-      results.output.push('✅ Server spotless check passed');
-    } catch (error) {
-      results.success = false;
-      results.errors.push('Server spotless check failed');
-      results.output.push(`❌ Server spotless check failed: ${error.message}`);
-    }
-  } catch (error) {
-    results.success = false;
-    results.errors.push(`General error in server checks: ${error.message}`);
-  }
-
-  return results;
-}
-
-/**
- * Runs all quality checks
- * @param {Object} context - The execution context
- * @returns {Object} Results of the checks
- */
-function runQualityChecks(context) {
-  console.log('Running pre-commit quality checks...');
-  
-  const changedFiles = getChangedFiles();
-  if (!changedFiles.length) {
-    return {
-      status: 'success',
-      message: 'No files to check'
-    };
-  }
-
-  const checksToRun = determineChecksToRun(changedFiles);
-  const results = {
-    success: true,
-    output: ['Starting quality checks for staged files...'],
-    clientChecks: null,
-    serverChecks: null
-  };
-
-  // Run client checks if client files have changed
-  if (checksToRun.clientChecks) {
-    results.output.push('\n=== Client Checks ===');
-    results.clientChecks = runClientChecks();
-    results.output = results.output.concat(results.clientChecks.output);
-    results.success = results.success && results.clientChecks.success;
-  }
-
-  // Run server checks if server files have changed
-  if (checksToRun.serverChecks) {
-    results.output.push('\n=== Server Checks ===');
-    results.serverChecks = runServerChecks();
-    results.output = results.output.concat(results.serverChecks.output);
-    results.success = results.success && results.serverChecks.success;
-  }
-
-  // If no checks were run, note that
-  if (!checksToRun.clientChecks && !checksToRun.serverChecks) {
-    results.output.push('No client or server files were changed, skipping checks');
-  }
-
-  if (results.success) {
-    return {
-      status: 'success',
-      message: 'All quality checks passed',
-      details: results.output.join('\n')
-    };
-  } else {
-    return {
-      status: 'failure',
-      message: 'Quality checks failed',
-      details: results.output.join('\n')
-    };
-  }
-}
-
-/**
- * Register command and hooks
- * @param {Object} context - The cursor context
- */
-function activate(context) {
-  // Register pre-commit hook
-  context.on('pre_commit', (event) => {
-    return runQualityChecks(context);
-  });
-  
-  // Register command for manual validation
-  context.registerCommand('run_quality_checks', () => {
-    return runQualityChecks(context);
-  });
-}
-
-module.exports = {
-  activate,
-  runQualityChecks
-};
-```
-
-## Usage
-
-This rule runs automatically on pre-commit events. You can also manually trigger it with the command `run_quality_checks`.
-
-### What It Checks
-
-1. **For Client-side Changes:**
-   - Runs linting checks
-   - Runs unit tests
-   - Checks for cyclic dependencies
-   - Runs prettier formatting validation
-
-2. **For Server-side Changes:**
-   - Runs unit tests
-   - Runs spotless formatting checks
-
-### Behavior
-
-- Only runs checks relevant to the files being committed (client and/or server)
-- Prevents commits if any checks fail
-- Provides detailed output about which checks passed or failed
-
-### Requirements
-
-- Node.js and yarn for client-side checks
-- Java and Gradle for server-side checks
-- Git for determining changed files
-
-### Customization
-
-You can customize which checks are run by modifying the `runClientChecks` and `runServerChecks` functions.
-
-### Example Output
-
-```
-Running pre-commit quality checks...
-Starting quality checks for staged files...
-
-=== Client Checks ===
-✅ Client lint passed
-✅ Client unit tests passed
-✅ No cyclic dependencies found
-✅ Prettier check passed
-
-=== Server Checks ===
-✅ Server unit tests passed
-✅ Server spotless check passed
-```
\ No newline at end of file
diff --git a/.cursor/rules/quality/react-hook-best-practices.mdc b/.cursor/rules/quality/react-hook-best-practices.mdc
deleted file mode 100644
index 0519ecba6ea9..000000000000
--- a/.cursor/rules/quality/react-hook-best-practices.mdc
+++ /dev/null
@@ -1 +0,0 @@
- 
\ No newline at end of file
diff --git a/.cursor/rules/server-unit-tests.mdc b/.cursor/rules/server-unit-tests.mdc
new file mode 100644
index 000000000000..1b92f754e7b0
--- /dev/null
+++ b/.cursor/rules/server-unit-tests.mdc
@@ -0,0 +1,131 @@
+---
+description:
+globs: app/server/**/*Test.java,app/server/**/*Tests.java
+alwaysApply: false
+---
+# Server Unit Test Conventions
+
+## Framework & Constraints
+
+- JUnit 5 exclusively — **JUnit 4 is banned** by maven-enforcer-plugin
+- Assertions: AssertJ (`assertThat`) preferred; JUnit 5 (`assertEquals`) also used
+- Reactive assertions: `StepVerifier` universally (`.create()`, `.assertNext()`, `.verifyComplete()`)
+- Mocking: Mockito (`@MockBean`, `@SpyBean`)
+- Controller tests: `@AutoConfigureWebTestClient` + `WebTestClient`
+
+## Running Tests
+
+Run a single test class:
+```bash
+cd app/server && source envs/test.env.example && mvn test -pl appsmith-server -Dtest=ClassName
+```
+
+- Docker must be running (Testcontainers manages Redis)
+- Unit tests use Flapdoodle Embedded MongoDB — do NOT start a local MongoDB instance
+- Integration tests live in `src/test/it` (not `src/test/java`)
+
+## Test Infrastructure (Managed Automatically)
+
+- **MongoDB**: Flapdoodle Embedded MongoDB 5.0.5 with replica set (for transactions)
+- **Redis**: Testcontainers `redis:6.2.6-alpine` auto-started
+- **Test data**: `SeedMongoData.java` seeds users (`api_user`, `usertest@usertest.com`), plugins, organizations
+- **Auth**: Most tests use `@WithUserDetails("api_user")` for authentication
+
+## Test Patterns
+
+### Integration test (most common)
+
+```java
+@SpringBootTest
+@DirtiesContext
+class SomeServiceTest {
+    @Autowired
+    private SomeService someService;
+
+    @Test
+    @WithUserDetails("api_user")
+    void methodName_scenario_expectedBehavior() {
+        Mono<Result> resultMono = someService.doSomething(input);
+
+        StepVerifier.create(resultMono)
+            .assertNext(result -> {
+                assertThat(result.getField()).isEqualTo(expected);
+            })
+            .verifyComplete();
+    }
+}
+```
+
+### Unit test with mocks
+
+```java
+@ExtendWith(MockitoExtension.class)
+class SomeServiceUnitTest {
+    @Mock
+    private DependencyService dependencyService;
+
+    @InjectMocks
+    private SomeServiceCEImpl serviceUnderTest;
+
+    @Test
+    void methodName_scenario_expectedBehavior() {
+        when(dependencyService.findById(any()))
+            .thenReturn(Mono.just(mockEntity));
+
+        StepVerifier.create(serviceUnderTest.doSomething("id"))
+            .assertNext(result -> assertThat(result).isNotNull())
+            .verifyComplete();
+    }
+}
+```
+
+### Controller test
+
+```java
+@SpringBootTest
+@AutoConfigureWebTestClient
+class SomeControllerTest {
+    @Autowired
+    private WebTestClient webTestClient;
+
+    @Test
+    @WithUserDetails("api_user")
+    void getEndpoint_validId_returnsSuccess() {
+        webTestClient.get()
+            .uri("/api/v1/resource/{id}", testId)
+            .exchange()
+            .expectStatus().isOk()
+            .expectBody()
+            .jsonPath("$.data.id").isEqualTo(testId);
+    }
+}
+```
+
+### Feature flag test
+
+```java
+@Test
+void method_featureFlagOn_executesEeLogic() {
+    Mockito.when(featureFlagService.check(eq(FeatureFlagEnum.SOME_FLAG)))
+        .thenReturn(Mono.just(true));
+
+    StepVerifier.create(service.someMethod())
+        .expectNext(eeExpectedValue)
+        .verifyComplete();
+}
+
+@Test
+void method_featureFlagOff_fallsToCeCompatible() {
+    // Default: flag returns false, aspect invokes superclass
+    StepVerifier.create(service.someMethod())
+        .expectNext(ceCompatibleExpectedValue)
+        .verifyComplete();
+}
+```
+
+## Key Conventions
+
+- Setup/teardown: `@BeforeEach` / `@AfterEach` with `.block()` for synchronous setup
+- Test naming: describe behavior — `methodName_scenario_expectedBehavior`
+- CE-EE testing: test both flag-on (EE path) and flag-off (CE/CE-Compatible fallback)
+- No `Thread.sleep()` — use `StepVerifier` with `Duration` or `await()` utilities
diff --git a/.cursor/rules/task-list.mdc b/.cursor/rules/task-list.mdc
deleted file mode 100644
index 1761f69ad1bf..000000000000
--- a/.cursor/rules/task-list.mdc
+++ /dev/null
@@ -1,100 +0,0 @@
-# Task List Management
-
-Guidelines for creating and managing task lists in Markdown files to track project progress
-
-## Task List Creation
-
-1. Create task lists in a markdown file (in the project root):
-   - Use `TASKS.md` or a descriptive name relevant to the feature (e.g., `ASSISTANT_CHAT.md`)
-   - Include a clear title and description of the feature being implemented
-
-2. Structure the file with these sections:
-   ```markdown
-   # Feature Name Implementation
-   
-   Brief description of the feature and its purpose.
-   
-   ## Completed Tasks
-   
-   - [x] Task 1 that has been completed
-   - [x] Task 2 that has been completed
-   
-   ## In Progress Tasks
-   
-   - [ ] Task 3 currently being worked on
-   - [ ] Task 4 to be completed soon
-   
-   ## Future Tasks
-   
-   - [ ] Task 5 planned for future implementation
-   - [ ] Task 6 planned for future implementation
-   
-   ## Implementation Plan
-   
-   Detailed description of how the feature will be implemented.
-   
-   ### Relevant Files
-   
-   - path/to/file1.ts - Description of purpose
-   - path/to/file2.ts - Description of purpose
-   ```
-
-## Task List Maintenance
-
-1. Update the task list as you progress:
-   - Mark tasks as completed by changing `[ ]` to `[x]`
-   - Add new tasks as they are identified
-   - Move tasks between sections as appropriate
-
-2. Keep "Relevant Files" section updated with:
-   - File paths that have been created or modified
-   - Brief descriptions of each file's purpose
-   - Status indicators (e.g., ✅) for completed components
-
-3. Add implementation details:
-   - Architecture decisions
-   - Data flow descriptions
-   - Technical components needed
-   - Environment configuration
-
-## AI Instructions
-
-When working with task lists, the AI should:
-
-1. Regularly update the task list file after implementing significant components
-2. Mark completed tasks with [x] when finished
-3. Add new tasks discovered during implementation
-4. Maintain the "Relevant Files" section with accurate file paths and descriptions
-5. Document implementation details, especially for complex features
-6. When implementing tasks one by one, first check which task to implement next
-7. After implementing a task, update the file to reflect progress
-
-## Example Task Update
-
-When updating a task from "In Progress" to "Completed":
-
-```markdown
-## In Progress Tasks
-
-- [ ] Implement database schema
-- [ ] Create API endpoints for data access
-
-## Completed Tasks
-
-- [x] Set up project structure
-- [x] Configure environment variables
-```
-
-Should become:
-
-```markdown
-## In Progress Tasks
-
-- [ ] Create API endpoints for data access
-
-## Completed Tasks
-
-- [x] Set up project structure
-- [x] Configure environment variables
-- [x] Implement database schema
-```
\ No newline at end of file
diff --git a/.cursor/rules/testing/test-generator.mdc b/.cursor/rules/testing/test-generator.mdc
deleted file mode 100644
index 0f52759bb0d9..000000000000
--- a/.cursor/rules/testing/test-generator.mdc
+++ /dev/null
@@ -1,295 +0,0 @@
----
-description: 
-globs: 
-alwaysApply: true
----
-# Test Generator
-
-```yaml
-name: Test Generator
-description: Automatically generates appropriate tests for code changes
-author: Cursor AI
-version: 1.0.0
-tags:
-  - testing
-  - automation
-  - quality
-activation:
-  always: true
-  event:
-    - file_change
-    - command
-triggers:
-  - file.created
-  - file.modified
-  - command: "generate_tests"
-```
-
-## Rule Definition
-
-This rule analyzes code changes and generates appropriate test cases to ensure proper test coverage.
-
-## Test Generation Logic
-
-```javascript
-// Main function to generate tests for code changes
-function generateTests(files, codebase) {
-  const testPlans = [];
-  
-  // Process each changed file
-  for (const file of files) {
-    if (shouldGenerateTestsFor(file)) {
-      const testPlan = createTestPlan(file, codebase);
-      testPlans.push(testPlan);
-    }
-  }
-  
-  return {
-    testPlans,
-    summary: `Generated ${testPlans.length} test plans`
-  };
-}
-
-// Determine if we should generate tests for a file
-function shouldGenerateTestsFor(file) {
-  // Skip test files, configuration files, etc.
-  if (file.path.includes('.test.') || file.path.includes('.spec.')) {
-    return false;
-  }
-  
-  // Skip certain file types
-  const skipExtensions = ['.md', '.json', '.yml', '.yaml', '.svg', '.png', '.jpg'];
-  if (skipExtensions.some(ext => file.path.endsWith(ext))) {
-    return false;
-  }
-  
-  return true;
-}
-
-// Create a test plan for the file
-function createTestPlan(file, codebase) {
-  const testType = determineTestType(file);
-  const testCases = analyzeFileForTestCases(file, codebase);
-  
-  return {
-    sourceFile: file.path,
-    testType,
-    testFile: generateTestFilePath(file, testType),
-    testCases,
-    testFramework: selectTestFramework(file)
-  };
-}
-
-// Determine the appropriate type of test
-function determineTestType(file) {
-  if (file.path.includes('app/client')) {
-    if (file.path.includes('/components/')) {
-      return 'component';
-    } else if (file.path.includes('/utils/')) {
-      return 'unit';
-    } else if (file.path.includes('/api/')) {
-      return 'integration';
-    }
-    return 'unit';
-  } else if (file.path.includes('app/server')) {
-    if (file.path.includes('/controllers/')) {
-      return 'controller';
-    } else if (file.path.includes('/services/')) {
-      return 'service';
-    } else if (file.path.includes('/repositories/')) {
-      return 'repository';
-    }
-    return 'unit';
-  }
-  
-  return 'unit'; // Default
-}
-
-// Analyze file to determine test cases needed
-function analyzeFileForTestCases(file, codebase) {
-  // This would contain complex analysis of the file
-  // to determine appropriate test cases
-  const testCases = [];
-  
-  // Example test cases for different file types
-  if (file.path.includes('.tsx') || file.path.includes('.jsx')) {
-    testCases.push(
-      { type: 'render', description: 'should render correctly' },
-      { type: 'props', description: 'should handle props correctly' },
-      { type: 'interaction', description: 'should handle user interactions' }
-    );
-  } else if (file.path.includes('.java')) {
-    testCases.push(
-      { type: 'normal', description: 'should execute successfully with valid input' },
-      { type: 'exception', description: 'should handle exceptions with invalid input' }
-    );
-  }
-  
-  return testCases;
-}
-
-// Generate path for the test file
-function generateTestFilePath(file, testType) {
-  if (file.path.includes('app/client')) {
-    const basePath = file.path.replace(/\.(ts|tsx|js|jsx)$/, '');
-    return `${basePath}.test.${file.path.split('.').pop()}`;
-  } else if (file.path.includes('app/server')) {
-    return file.path.replace(/\.java$/, 'Test.java');
-  }
-  
-  return file.path + '.test';
-}
-
-// Select appropriate test framework
-function selectTestFramework(file) {
-  if (file.path.includes('app/client')) {
-    if (file.path.includes('/cypress/')) {
-      return 'cypress';
-    }
-    return 'jest';
-  } else if (file.path.includes('app/server')) {
-    return 'junit';
-  }
-  
-  return 'jest'; // Default
-}
-
-// Generate actual test code based on the test plan
-function generateTestCode(testPlan) {
-  // This would create the actual test code based on the framework and test cases
-  // This is a placeholder that would contain complex logic to generate tests
-  return "// Generated test code would go here";
-}
-
-// Run on activation
-function activate(context) {
-  // Register event handlers
-  context.on('file.created', (event) => {
-    const file = context.getFileContent(event.file.path);
-    const codebase = context.getCodebase();
-    return generateTests([file], codebase);
-  });
-  
-  context.on('file.modified', (event) => {
-    const file = context.getFileContent(event.file.path);
-    const codebase = context.getCodebase();
-    return generateTests([file], codebase);
-  });
-  
-  context.registerCommand('generate_tests', (args) => {
-    const filePath = args.file || context.getCurrentFilePath();
-    if (!filePath) {
-      return {
-        status: "error",
-        message: "No file specified"
-      };
-    }
-    
-    const file = context.getFileContent(filePath);
-    const codebase = context.getCodebase();
-    return generateTests([file], codebase);
-  });
-}
-
-// Export functions
-module.exports = {
-  activate,
-  generateTests,
-  generateTestCode,
-  shouldGenerateTestsFor,
-  createTestPlan
-};
-```
-
-## When It Runs
-
-This rule can be triggered:
-- When code changes are made and tests need to be created
-- When a new file is created
-- When an existing file is modified
-- When a developer runs the `generate_tests` command in Cursor
-- When submitting a PR with code changes that lack tests
-
-## Usage Example
-
-1. Make code changes to a file
-2. Run `generate_tests` in Cursor
-3. Review the generated test plan
-4. Accept or modify the suggested tests
-5. Run the tests to verify your changes
-
-## Test Generation Best Practices
-
-### Frontend Tests
-
-For React components, tests should typically verify:
-
-- Component renders without crashing
-- Props are correctly handled
-- User interactions work as expected
-- Edge cases are handled properly
-
-Example Jest test for a React component:
-
-```jsx
-import React from 'react';
-import { render, screen, fireEvent } from '@testing-library/react';
-import Button from './Button';
-
-describe('Button component', () => {
-  it('renders correctly', () => {
-    render(<Button label="Click me" />);
-    expect(screen.getByText('Click me')).toBeInTheDocument();
-  });
-
-  it('calls onClick handler when clicked', () => {
-    const handleClick = jest.fn();
-    render(<Button label="Click me" onClick={handleClick} />);
-    fireEvent.click(screen.getByText('Click me'));
-    expect(handleClick).toHaveBeenCalledTimes(1);
-  });
-});
-```
-
-### Backend Tests
-
-For Java services, tests should typically verify:
-
-- Methods return expected results for valid inputs
-- Proper exception handling for invalid inputs
-- Business logic is correctly implemented
-- Edge cases are handled properly
-
-Example JUnit test for a Java service:
-
-```java
-@RunWith(SpringRunner.class)
-@SpringBootTest
-public class UserServiceTest {
-    
-    @Autowired
-    private UserService userService;
-    
-    @Test
-    public void testCreateUser_ValidInput_ReturnsCreatedUser() {
-        User user = new User("test@example.com", "password");
-        User result = userService.createUser(user).block();
-        
-        assertNotNull(result);
-        assertNotNull(result.getId());
-        assertEquals("test@example.com", result.getEmail());
-    }
-    
-    @Test
-    public void testCreateUser_DuplicateEmail_ThrowsException() {
-        User user = new User("existing@example.com", "password");
-        
-        // First creation should succeed
-        userService.createUser(user).block();
-        
-        // Second attempt with same email should fail
-        StepVerifier.create(userService.createUser(user))
-                .expectError(DuplicateUserException.class)
-                .verify();
-    }
-} 
\ No newline at end of file
diff --git a/.cursor/rules/verification/bug-fix-verifier.mdc b/.cursor/rules/verification/bug-fix-verifier.mdc
deleted file mode 100644
index 36a1c73d7c84..000000000000
--- a/.cursor/rules/verification/bug-fix-verifier.mdc
+++ /dev/null
@@ -1,717 +0,0 @@
----
-description: 
-globs: 
-alwaysApply: true
----
----
-description: 
-globs: 
-alwaysApply: true
----
-# Bug Fix Verifier
-
-```yaml
-name: Bug Fix Verifier
-description: Guides developers through proper bug fixing steps and verifies fix quality
-author: Cursor AI
-version: 1.0.0
-tags:
-  - bug
-  - fixes
-  - verification
-  - testing
-activation:
-  always: true
-  event:
-    - pull_request
-    - command
-    - file_change
-triggers:
-  - pull_request.created
-  - pull_request.updated
-  - pull_request.labeled:bug
-  - pull_request.labeled:fix
-  - command: "verify_bug_fix"
-```
-
-## Rule Definition
-
-This rule guides developers through the proper steps to fix bugs and verifies that the fix meets quality standards.
-
-## Bug Fix Verification Logic
-
-```javascript
-// Main function to verify bug fixes
-function verifyBugFix(files, tests, issue) {
-  const results = {
-    reproduction: checkReproduction(issue),
-    testCoverage: checkTestCoverage(files, tests),
-    implementation: checkImplementation(files, issue),
-    regressionTesting: checkRegressionTesting(tests),
-    performance: checkPerformanceImplications(files),
-    score: 0,
-    issues: [],
-    recommendations: []
-  };
-  
-  // Calculate overall score
-  results.score = calculateScore(results);
-  
-  // Generate issues and recommendations
-  results.issues = identifyIssues(results);
-  results.recommendations = generateRecommendations(results.issues);
-  
-  return {
-    ...results,
-    summary: generateSummary(results)
-  };
-}
-
-// Check if the bug is properly reproduced in tests
-function checkReproduction(issue) {
-  const results = {
-    hasReproductionSteps: false,
-    hasReproductionTest: false,
-    clearStepsToReproduce: false,
-    missingElements: []
-  };
-  
-  if (!issue) {
-    results.missingElements.push('issue reference');
-    return results;
-  }
-  
-  // Check if there are clear steps to reproduce
-  results.hasReproductionSteps = 
-    issue.description && 
-    (issue.description.includes('Steps to reproduce') || 
-     issue.description.includes('Reproduction steps'));
-  
-  if (!results.hasReproductionSteps) {
-    results.missingElements.push('clear reproduction steps');
-  }
-  
-  // Check if reproduction steps are clear
-  if (results.hasReproductionSteps) {
-    const stepsSection = extractReproductionSteps(issue.description);
-    results.clearStepsToReproduce = stepsSection && stepsSection.split('\n').length >= 3;
-  }
-  
-  if (!results.clearStepsToReproduce) {
-    results.missingElements.push('detailed reproduction steps');
-  }
-  
-  // Check if there's a test that reproduces the bug
-  results.hasReproductionTest = issue.tests && issue.tests.some(test => 
-    test.includes('test') && test.includes('reproduce')
-  );
-  
-  if (!results.hasReproductionTest) {
-    results.missingElements.push('test that reproduces the bug');
-  }
-  
-  return results;
-}
-
-// Check test coverage of the bug fix
-function checkTestCoverage(files, tests) {
-  const results = {
-    hasTestsForFix: false,
-    testsVerifyFix: false,
-    hasRegressionTests: false,
-    hasUnitTests: false,
-    hasE2ETests: false,
-    testQuality: 0,
-    missingTests: []
-  };
-  
-  if (!tests || tests.length === 0) {
-    results.missingTests.push('any tests for this fix');
-    return results;
-  }
-  
-  // Check if there are tests for the fix
-  results.hasTestsForFix = true;
-  
-  // Check if tests verify the fix
-  results.testsVerifyFix = tests.some(test => 
-    (test.includes('assert') || test.includes('expect')) && 
-    !test.includes('.skip') && 
-    !test.includes('.todo')
-  );
-  
-  if (!results.testsVerifyFix) {
-    results.missingTests.push('tests that verify the fix works');
-  }
-  
-  // Check for regression tests
-  results.hasRegressionTests = tests.some(test => 
-    test.includes('regression') || 
-    test.includes('should not') || 
-    test.includes('should still')
-  );
-  
-  if (!results.hasRegressionTests) {
-    results.missingTests.push('regression tests');
-  }
-  
-  // Check for unit tests
-  results.hasUnitTests = tests.some(test => 
-    test.includes('.test.') || 
-    test.includes('Test.java') ||
-    test.includes('__tests__')
-  );
-  
-  if (!results.hasUnitTests) {
-    results.missingTests.push('unit tests to verify the specific fix');
-  }
-  
-  // Check for end-to-end tests for user-facing changes
-  const isUserFacingChange = files.some(file => 
-    file.path.includes('/components/') || 
-    file.path.includes('/pages/') ||
-    file.path.includes('/ui/') ||
-    file.path.includes('/views/')
-  );
-  
-  if (isUserFacingChange) {
-    results.hasE2ETests = tests.some(test => 
-      test.includes('/e2e/') || 
-      test.includes('/cypress/')
-    );
-    
-    if (!results.hasE2ETests) {
-      results.missingTests.push('end-to-end tests for this user-facing change');
-    }
-  }
-  
-  // Evaluate test quality (improved)
-  let qualityScore = 0;
-  if (results.hasTestsForFix) qualityScore += 20;
-  if (results.testsVerifyFix) qualityScore += 25;
-  if (results.hasRegressionTests) qualityScore += 20;
-  if (results.hasUnitTests) qualityScore += 20;
-  if (results.hasE2ETests || !isUserFacingChange) qualityScore += 15;
-  
-  results.testQuality = qualityScore;
-  
-  return results;
-}
-
-// Check the quality of the implementation
-function checkImplementation(files, issue) {
-  const results = {
-    addressesRootCause: false,
-    isMinimalChange: false,
-    hasNoHardcodedValues: true,
-    followsGoodPractices: true,
-    concerns: []
-  };
-  
-  if (!files || files.length === 0) {
-    results.concerns.push('no implementation files found');
-    return results;
-  }
-  
-  // Check if the implementation addresses the root cause
-  if (issue && issue.title) {
-    const keywords = extractKeywords(issue.title);
-    const filesContent = files.map(file => file.content).join(' ');
-    
-    results.addressesRootCause = keywords.some(keyword => 
-      filesContent.includes(keyword)
-    );
-  }
-  
-  if (!results.addressesRootCause) {
-    results.concerns.push('may not address the root cause');
-  }
-  
-  // Check if changes are minimal
-  const totalChangedLines = files.reduce((sum, file) => {
-    return sum + countChangedLines(file);
-  }, 0);
-  
-  results.isMinimalChange = totalChangedLines < 50;
-  
-  if (!results.isMinimalChange) {
-    results.concerns.push('changes are not minimal');
-  }
-  
-  // Check for hardcoded values
-  const hardcodedPattern = /'[a-zA-Z0-9]{10,}'/;
-  results.hasNoHardcodedValues = !files.some(file => 
-    hardcodedPattern.test(file.content)
-  );
-  
-  if (!results.hasNoHardcodedValues) {
-    results.concerns.push('contains hardcoded values');
-  }
-  
-  // Check for unsafe property access in Redux/React applications
-  const unsafePropertyAccess = files.some(file => {
-    // Check if this is a Redux/React file
-    const isReduxReactFile = file.path.includes('.jsx') || 
-                             file.path.includes('.tsx') ||
-                             file.content.includes('import { useSelector }') ||
-                             file.content.includes('import { connect }');
-                             
-    if (!isReduxReactFile) return false;
-    
-    // Check for potentially unsafe deep property access
-    const hasNestedProps = file.content.includes('?.');
-    const hasObjectChaining = /\w+\.\w+\.\w+/.test(file.content);
-    const usesLodashGet = file.content.includes('import get from') || 
-                          file.content.includes('lodash/get');
-                         
-    // If file has nested properties but doesn't use lodash get or optional chaining
-    return (hasObjectChaining && !hasNestedProps && !usesLodashGet);
-  });
-  
-  if (unsafePropertyAccess) {
-    results.followsGoodPractices = false;
-    results.concerns.push('contains unsafe nested property access, consider using lodash/get or optional chaining');
-  }
-  
-  // Check for good practices
-  const badPractices = [
-    { pattern: /\/\/ TODO:/, message: 'contains TODO comments' },
-    { pattern: /console\.log\(/, message: 'contains debug logging' },
-    { pattern: /Thread\.sleep\(/, message: 'contains blocking calls' },
-    { pattern: /alert\(/, message: 'contains alert() calls' }
-  ];
-  
-  badPractices.forEach(practice => {
-    if (files.some(file => practice.pattern.test(file.content))) {
-      results.followsGoodPractices = false;
-      results.concerns.push(practice.message);
-    }
-  });
-  
-  return results;
-}
-
-// Check regression testing
-function checkRegressionTesting(tests) {
-  const results = {
-    hasRegressionTests: false,
-    coversRelatedFunctionality: false,
-    hasEdgeCaseTests: false,
-    missingTestAreas: []
-  };
-  
-  if (!tests || tests.length === 0) {
-    results.missingTestAreas.push('regression tests');
-    results.missingTestAreas.push('related functionality tests');
-    results.missingTestAreas.push('edge case tests');
-    return results;
-  }
-  
-  // Check for regression tests
-  results.hasRegressionTests = tests.some(test => 
-    test.includes('regression') || 
-    test.includes('should not') || 
-    test.includes('should still')
-  );
-  
-  if (!results.hasRegressionTests) {
-    results.missingTestAreas.push('regression tests');
-  }
-  
-  // Check if tests cover related functionality
-  results.coversRelatedFunctionality = tests.some(test => 
-    test.includes('related') || 
-    test.includes('integration') || 
-    test.includes('with') || 
-    test.includes('when used')
-  );
-  
-  if (!results.coversRelatedFunctionality) {
-    results.missingTestAreas.push('tests for related functionality');
-  }
-  
-  // Check for edge case tests
-  results.hasEdgeCaseTests = tests.some(test => 
-    test.includes('edge case') || 
-    test.includes('boundary') || 
-    test.includes('limit') || 
-    test.includes('extreme')
-  );
-  
-  if (!results.hasEdgeCaseTests) {
-    results.missingTestAreas.push('edge case tests');
-  }
-  
-  return results;
-}
-
-// Check performance implications of the fix
-function checkPerformanceImplications(files) {
-  const results = {
-    noRegressions: true,
-    analyzedPerformance: false,
-    potentialIssues: []
-  };
-  
-  if (!files || files.length === 0) {
-    return results;
-  }
-  
-  // Check for performance regressions
-  const regressionPatterns = [
-    { pattern: /for\s*\([^)]*\)\s*\{[^}]*for\s*\([^)]*\)/, message: 'nested loops may cause performance issues' },
-    { pattern: /Thread\.sleep\(|setTimeout\(/, message: 'blocking calls may affect performance' },
-    { pattern: /new [A-Z][a-zA-Z0-9]*\(.*\)/g, message: 'excessive object creation may affect memory usage' }
-  ];
-  
-  regressionPatterns.forEach(pattern => {
-    if (files.some(file => pattern.pattern.test(file.content))) {
-      results.noRegressions = false;
-      results.potentialIssues.push(pattern.message);
-    }
-  });
-  
-  // Check if performance was analyzed
-  results.analyzedPerformance = files.some(file => 
-    file.content.includes('performance') || 
-    file.content.includes('benchmark') || 
-    file.content.includes('optimize')
-  );
-  
-  return results;
-}
-
-// Calculate overall score for the bug fix
-function calculateScore(results) {
-  let score = 100;
-  
-  // Deduct for missing reproduction elements
-  score -= results.reproduction.missingElements.length * 10;
-  
-  // Deduct for missing tests
-  score -= results.testCoverage.missingTests.length * 15;
-  
-  // Deduct for implementation concerns
-  score -= results.implementation.concerns.length * 10;
-  
-  // Deduct for missing regression test areas
-  score -= results.regressionTesting.missingTestAreas.length * 5;
-  
-  // Deduct for performance issues
-  score -= results.performance.potentialIssues.length * 8;
-  
-  return Math.max(0, Math.round(score));
-}
-
-// Identify issues from all verification checks
-function identifyIssues(results) {
-  const issues = [];
-  
-  // Add reproduction issues
-  results.reproduction.missingElements.forEach(element => {
-    issues.push({
-      type: 'reproduction',
-      severity: 'high',
-      message: `Missing ${element}`
-    });
-  });
-  
-  // Add test coverage issues
-  results.testCoverage.missingTests.forEach(test => {
-    issues.push({
-      type: 'testing',
-      severity: 'high',
-      message: `Missing ${test}`
-    });
-  });
-  
-  // Add implementation issues
-  results.implementation.concerns.forEach(concern => {
-    issues.push({
-      type: 'implementation',
-      severity: 'medium',
-      message: `Implementation ${concern}`
-    });
-  });
-  
-  // Add regression testing issues
-  results.regressionTesting.missingTestAreas.forEach(area => {
-    issues.push({
-      type: 'regression',
-      severity: 'medium',
-      message: `Missing ${area}`
-    });
-  });
-  
-  // Add performance issues
-  results.performance.potentialIssues.forEach(issue => {
-    issues.push({
-      type: 'performance',
-      severity: 'medium',
-      message: `Performance concern: ${issue}`
-    });
-  });
-  
-  return issues;
-}
-
-// Generate recommendations based on identified issues
-function generateRecommendations(issues) {
-  const recommendations = [];
-  
-  // Group issues by type
-  const issuesByType = {};
-  issues.forEach(issue => {
-    if (!issuesByType[issue.type]) {
-      issuesByType[issue.type] = [];
-    }
-    issuesByType[issue.type].push(issue);
-  });
-  
-  // Generate recommendations for requirements issues
-  if (issuesByType.requirements) {
-    recommendations.push({
-      type: 'requirements',
-      title: 'Complete the implementation of requirements',
-      steps: [
-        'Review the missing requirements and ensure they are implemented',
-        'Verify that the implementation matches the acceptance criteria',
-        'Update the code to address all missing requirements'
-      ]
-    });
-  }
-  
-  // Generate recommendations for testing issues
-  if (issuesByType.testing) {
-    recommendations.push({
-      type: 'testing',
-      title: 'Improve test coverage',
-      steps: [
-        'Add unit tests for untested files',
-        'Create integration tests where appropriate',
-        'Ensure all edge cases are covered in tests'
-      ]
-    });
-  }
-  
-  // Generate recommendations for code quality issues
-  if (issuesByType.code_quality) {
-    recommendations.push({
-      type: 'code_quality',
-      title: 'Address code quality issues',
-      steps: [
-        'Remove debugging code (console.log, TODO comments)',
-        'Fix formatting and indentation issues',
-        'Follow project coding standards and best practices',
-        'Use proper data access methods like lodash/get for deeply nested objects',
-        'Consider data nullability and use optional chaining or default values'
-      ]
-    });
-  }
-  
-  // Generate recommendations for documentation issues
-  if (issuesByType.documentation) {
-    recommendations.push({
-      type: 'documentation',
-      title: 'Improve documentation',
-      steps: [
-        'Add JSDoc or JavaDoc comments to public APIs and classes',
-        'Document complex components and their usage',
-        'Ensure all services have proper documentation'
-      ]
-    });
-  }
-  
-  return recommendations;
-}
-
-// Generate a summary of the verification results
-function generateSummary(results) {
-  const score = results.score;
-  let status = '';
-  
-  if (score >= 90) {
-    status = 'EXCELLENT';
-  } else if (score >= 70) {
-    status = 'GOOD';
-  } else if (score >= 50) {
-    status = 'NEEDS IMPROVEMENT';
-  } else {
-    status = 'POOR';
-  }
-  
-  return {
-    score,
-    status,
-    issues: results.issues.length,
-    critical: results.issues.filter(issue => issue.severity === 'high').length,
-    recommendations: results.recommendations.length,
-    message: generateSummaryMessage(score, status, results)
-  };
-}
-
-// Generate a summary message based on results
-function generateSummaryMessage(score, status, results) {
-  if (status === 'EXCELLENT') {
-    return 'The bug fix meets or exceeds all quality standards. Good job!';
-  } else if (status === 'GOOD') {
-    return `The bug fix is good overall but has ${results.issues.length} issues to address.`;
-  } else if (status === 'NEEDS IMPROVEMENT') {
-    const critical = results.issues.filter(issue => issue.severity === 'high').length;
-    return `The bug fix needs significant improvement with ${critical} critical issues.`;
-  } else {
-    return 'The bug fix is incomplete and does not meet minimum quality standards.';
-  }
-}
-
-// Helper function to extract reproduction steps from issue description
-function extractReproductionSteps(description) {
-  if (!description) return null;
-  
-  const stepSectionMarkers = [
-    'Steps to reproduce',
-    'Reproduction steps',
-    'To reproduce',
-    'How to reproduce'
-  ];
-  
-  for (const marker of stepSectionMarkers) {
-    const markerIndex = description.indexOf(marker);
-    if (markerIndex >= 0) {
-      const startIndex = markerIndex + marker.length;
-      let endIndex = description.indexOf('\n\n', startIndex);
-      if (endIndex < 0) endIndex = description.length;
-      
-      return description.substring(startIndex, endIndex).trim();
-    }
-  }
-  
-  return null;
-}
-
-// Helper function to extract keywords from issue title
-function extractKeywords(title) {
-  if (!title) return [];
-  
-  // Remove common words
-  const commonWords = ['a', 'an', 'the', 'in', 'on', 'at', 'to', 'for', 'with', 'by', 'is'];
-  let words = title.split(/\s+/)
-    .map(word => word.toLowerCase().replace(/[^\w]/g, ''))
-    .filter(word => word.length > 2 && !commonWords.includes(word));
-  
-  return [...new Set(words)]; // Remove duplicates
-}
-
-// Helper function to count changed lines in a file
-function countChangedLines(file) {
-  if (!file.diff) return file.content.split('\n').length;
-  
-  let changedLines = 0;
-  const diffLines = file.diff.split('\n');
-  
-  for (const line of diffLines) {
-    if (line.startsWith('+') || line.startsWith('-')) {
-      changedLines++;
-    }
-  }
-  
-  return changedLines;
-}
-
-// Run on activation
-function activate(context) {
-  // Register event handlers
-  context.on('pull_request.created', (event) => {
-    const files = context.getPullRequestFiles(event.pullRequest.id);
-    const tests = context.getPullRequestTests(event.pullRequest.id);
-    const issue = context.getLinkedIssue(event.pullRequest);
-    return verifyBugFix(files, tests, issue);
-  });
-  
-  context.on('pull_request.updated', (event) => {
-    const files = context.getPullRequestFiles(event.pullRequest.id);
-    const tests = context.getPullRequestTests(event.pullRequest.id);
-    const issue = context.getLinkedIssue(event.pullRequest);
-    return verifyBugFix(files, tests, issue);
-  });
-  
-  context.on('pull_request.labeled:bug', (event) => {
-    const files = context.getPullRequestFiles(event.pullRequest.id);
-    const tests = context.getPullRequestTests(event.pullRequest.id);
-    const issue = context.getLinkedIssue(event.pullRequest);
-    return verifyBugFix(files, tests, issue);
-  });
-  
-  context.on('pull_request.labeled:fix', (event) => {
-    const files = context.getPullRequestFiles(event.pullRequest.id);
-    const tests = context.getPullRequestTests(event.pullRequest.id);
-    const issue = context.getLinkedIssue(event.pullRequest);
-    return verifyBugFix(files, tests, issue);
-  });
-  
-  context.registerCommand('verify_bug_fix', (args) => {
-    const prId = args.pullRequest;
-    if (!prId) {
-      return {
-        status: "error",
-        message: "No pull request specified"
-      };
-    }
-    
-    const files = context.getPullRequestFiles(prId);
-    const tests = context.getPullRequestTests(prId);
-    const issue = context.getLinkedIssue({id: prId});
-    return verifyBugFix(files, tests, issue);
-  });
-}
-
-// Export functions
-module.exports = {
-  activate,
-  verifyBugFix,
-  checkReproduction,
-  checkTestCoverage,
-  checkImplementation,
-  checkRegressionTesting,
-  checkPerformanceImplications
-};
-```
-
-## When It Runs
-
-This rule can be triggered:
-- When a bug fix pull request is created
-- When a pull request is updated
-- When a pull request is labeled with 'bug' or 'fix'
-- When a developer runs the `verify_bug_fix` command in Cursor
-- Before committing changes meant to fix a bug
-
-## Usage Example
-
-1. Create a pull request for a bug fix
-2. Run `verify_bug_fix --pullRequest=123` in Cursor
-3. Review the verification results
-4. Address any identified issues
-5. Re-run verification to confirm all issues are resolved
-
-## Bug Fix Best Practices
-
-### Reproduction Checklist
-
-- [ ] Document clear steps to reproduce the bug
-- [ ] Create a test that reproduces the bug before fixing
-- [ ] Ensure the reproduction is reliable and consistent
-
-### Fix Implementation Checklist
-
-- [ ] Address the root cause, not just symptoms
-- [ ] Make changes as minimal and focused as possible
-- [ ] Avoid introducing new bugs or regressions
-- [ ] Follow project coding standards and patterns
-
-### Testing Checklist
-
-- [ ] Verify the fix resolves the issue
-- [ ] Test related functionality that might be affected
-- [ ] Consider edge cases and boundary conditions
-- [ ] Ensure all tests pass after the fix
\ No newline at end of file
diff --git a/.cursor/rules/verification/feature-implementation-validator.mdc b/.cursor/rules/verification/feature-implementation-validator.mdc
deleted file mode 100644
index bbb107423614..000000000000
--- a/.cursor/rules/verification/feature-implementation-validator.mdc
+++ /dev/null
@@ -1,744 +0,0 @@
----
-description: 
-globs: 
-alwaysApply: true
----
- # Feature Implementation Validator
-
-```yaml
-name: Feature Implementation Validator
-description: Validates that new features are completely and correctly implemented
-author: Cursor AI
-version: 1.0.0
-tags:
-  - feature
-  - implementation
-  - quality
-  - validation
-activation:
-  always: true
-  event:
-    - pull_request
-    - command
-triggers:
-  - pull_request.created
-  - pull_request.updated
-  - pull_request.labeled:feature
-  - command: "validate_feature"
-```
-
-## Rule Definition
-
-This rule ensures that new feature implementations meet quality standards, including proper testing, documentation, and adherence to best practices.
-
-## Feature Validation Logic
-
-```javascript
-// Main function to validate feature implementation
-function validateFeature(files, codebase, pullRequest) {
-  const results = {
-    completeness: checkCompleteness(files, codebase),
-    tests: checkTestCoverage(files, codebase),
-    documentation: checkDocumentation(files, codebase),
-    bestPractices: checkBestPractices(files, codebase),
-    accessibility: checkAccessibility(files, codebase),
-    score: 0,
-    issues: [],
-    recommendations: []
-  };
-  
-  // Calculate overall score
-  results.score = calculateScore(results);
-  
-  // Generate issues and recommendations
-  results.issues = identifyIssues(results);
-  results.recommendations = generateRecommendations(results.issues);
-  
-  return {
-    ...results,
-    summary: generateSummary(results)
-  };
-}
-
-// Check if the feature implementation is complete
-function checkCompleteness(files, codebase) {
-  const results = {
-    hasImplementation: false,
-    hasTests: false,
-    hasDocumentation: false,
-    missingComponents: []
-  };
-  
-  // Check for implementation files
-  const implementationFiles = files.filter(file => {
-    return !file.path.includes('.test.') && 
-           !file.path.includes('.spec.') && 
-           !file.path.includes('docs/') && 
-           !file.path.endsWith('.md');
-  });
-  
-  results.hasImplementation = implementationFiles.length > 0;
-  
-  // Check for test files
-  const testFiles = files.filter(file => {
-    return file.path.includes('.test.') || file.path.includes('.spec.');
-  });
-  
-  results.hasTests = testFiles.length > 0;
-  
-  // Check for documentation
-  const docFiles = files.filter(file => {
-    return file.path.includes('docs/') || file.path.endsWith('.md');
-  });
-  
-  results.hasDocumentation = docFiles.length > 0;
-  
-  // Identify missing components
-  if (!results.hasImplementation) {
-    results.missingComponents.push('implementation');
-  }
-  
-  if (!results.hasTests) {
-    results.missingComponents.push('tests');
-  }
-  
-  if (!results.hasDocumentation) {
-    results.missingComponents.push('documentation');
-  }
-  
-  // Check for missing components based on feature type
-  const featureType = identifyFeatureType(files);
-  if (featureType === 'ui' && !hasUiComponents(files)) {
-    results.missingComponents.push('UI components');
-  }
-  
-  if (featureType === 'api' && !hasApiEndpoints(files)) {
-    results.missingComponents.push('API endpoints');
-  }
-  
-  return results;
-}
-
-// Check test coverage of the feature
-function checkTestCoverage(files, codebase) {
-  const results = {
-    hasFunctionalTests: false,
-    hasUnitTests: false,
-    hasIntegrationTests: false,
-    coverage: 0,
-    untested: []
-  };
-  
-  // Get all non-test implementation files
-  const implFiles = files.filter(file => {
-    return !file.path.includes('.test.') && 
-           !file.path.includes('.spec.') && 
-           !file.path.endsWith('.md');
-  });
-  
-  // Check for different test types
-  const testFiles = files.filter(file => {
-    return file.path.includes('.test.') || file.path.includes('.spec.');
-  });
-  
-  results.hasFunctionalTests = testFiles.some(file => 
-    file.content.includes('test(') && 
-    (file.content.includes('render(') || file.content.includes('fireEvent'))
-  );
-  
-  results.hasUnitTests = testFiles.some(file => 
-    file.content.includes('test(') && 
-    !file.content.includes('render(')
-  );
-  
-  results.hasIntegrationTests = testFiles.some(file => 
-    file.content.includes('describe(') && 
-    file.content.includes('integration')
-  );
-  
-  // Calculate rough coverage
-  let testedFunctions = 0;
-  let totalFunctions = 0;
-  
-  implFiles.forEach(file => {
-    const functions = extractFunctions(file.content);
-    totalFunctions += functions.length;
-    
-    functions.forEach(func => {
-      // Check if function is tested in any test file
-      const isTested = testFiles.some(testFile => 
-        testFile.content.includes(func.name)
-      );
-      
-      if (isTested) {
-        testedFunctions++;
-      } else {
-        results.untested.push(func.name);
-      }
-    });
-  });
-  
-  results.coverage = totalFunctions ? (testedFunctions / totalFunctions) * 100 : 0;
-  
-  return results;
-}
-
-// Check if documentation is complete
-function checkDocumentation(files, codebase) {
-  const results = {
-    hasUserDocs: false,
-    hasDeveloperDocs: false,
-    hasApiDocs: false,
-    missingDocs: []
-  };
-  
-  // Check for documentation files
-  const docFiles = files.filter(file => {
-    return file.path.includes('docs/') || file.path.endsWith('.md');
-  });
-  
-  // Check for user documentation
-  results.hasUserDocs = docFiles.some(file => 
-    file.content.includes('user') || 
-    file.content.includes('guide') || 
-    file.path.includes('user')
-  );
-  
-  // Check for developer documentation
-  results.hasDeveloperDocs = docFiles.some(file => 
-    file.content.includes('developer') || 
-    file.content.includes('implementation') || 
-    file.path.includes('dev')
-  );
-  
-  // Check for API documentation
-  results.hasApiDocs = docFiles.some(file => 
-    file.content.includes('API') || 
-    file.content.includes('endpoint') || 
-    file.path.includes('api')
-  );
-  
-  // Identify missing documentation
-  if (!results.hasUserDocs) {
-    results.missingDocs.push('user documentation');
-  }
-  
-  if (!results.hasDeveloperDocs) {
-    results.missingDocs.push('developer documentation');
-  }
-  
-  const hasApiCode = files.some(file => 
-    file.path.includes('api') || 
-    file.content.includes('axios') || 
-    file.content.includes('fetch')
-  );
-  
-  if (hasApiCode && !results.hasApiDocs) {
-    results.missingDocs.push('API documentation');
-  }
-  
-  return results;
-}
-
-// Check adherence to best practices
-function checkBestPractices(files, codebase) {
-  const results = {
-    followsNamingConventions: true,
-    followsArchitecture: true,
-    hasCleanCode: true,
-    violations: []
-  };
-  
-  // Check for naming convention violations
-  files.forEach(file => {
-    if (file.path.includes('.tsx') || file.path.includes('.jsx')) {
-      // React component should use PascalCase
-      const filename = file.path.split('/').pop().split('.')[0];
-      if (!/^[A-Z][a-zA-Z0-9]*$/.test(filename)) {
-        results.followsNamingConventions = false;
-        results.violations.push(`React component "${filename}" should use PascalCase`);
-      }
-    }
-    
-    if (file.path.includes('.java')) {
-      // Java classes should use PascalCase
-      const filename = file.path.split('/').pop().split('.')[0];
-      if (!/^[A-Z][a-zA-Z0-9]*$/.test(filename)) {
-        results.followsNamingConventions = false;
-        results.violations.push(`Java class "${filename}" should use PascalCase`);
-      }
-    }
-  });
-  
-  // Check for architectural violations
-  files.forEach(file => {
-    if (file.path.includes('app/client/components') && file.content.includes('fetch(')) {
-      results.followsArchitecture = false;
-      results.violations.push('Components should not make API calls directly, use services instead');
-    }
-    
-    if (file.path.includes('app/server/controllers') && file.content.includes('Repository')) {
-      results.followsArchitecture = false;
-      results.violations.push('Controllers should not access repositories directly, use services instead');
-    }
-  });
-  
-  // Check for clean code issues
-  files.forEach(file => {
-    // Check for long functions (more than 50 lines)
-    const functions = extractFunctions(file.content);
-    functions.forEach(func => {
-      if (func.lines > 50) {
-        results.hasCleanCode = false;
-        results.violations.push(`Function "${func.name}" is too long (${func.lines} lines)`);
-      }
-    });
-    
-    // Check for high complexity (nested conditionals)
-    if (/if\s*\([^)]*\)\s*\{[^{}]*if\s*\([^)]*\)/g.test(file.content)) {
-      results.hasCleanCode = false;
-      results.violations.push('Nested conditionals detected, consider refactoring');
-    }
-    
-    // Check for commented-out code
-    if (/\/\/\s*[a-zA-Z0-9]+.*\(.*\).*\{/g.test(file.content)) {
-      results.hasCleanCode = false;
-      results.violations.push('Commented-out code detected, remove or refactor');
-    }
-  });
-  
-  return results;
-}
-
-// Check accessibility (for UI features)
-function checkAccessibility(files, codebase) {
-  const results = {
-    hasA11yAttributes: false,
-    hasKeyboardNavigation: false,
-    hasSemanticsHtml: false,
-    issues: []
-  };
-  
-  // Only check UI files
-  const uiFiles = files.filter(file => {
-    return (file.path.includes('.tsx') || file.path.includes('.jsx')) && 
-           file.path.includes('component');
-  });
-  
-  if (uiFiles.length === 0) {
-    // Not a UI feature, mark as not applicable
-    return {
-      notApplicable: true
-    };
-  }
-  
-  // Check for accessibility attributes
-  results.hasA11yAttributes = uiFiles.some(file => 
-    file.content.includes('aria-') || 
-    file.content.includes('role=')
-  );
-  
-  if (!results.hasA11yAttributes) {
-    results.issues.push('No ARIA attributes found in UI components');
-  }
-  
-  // Check for keyboard navigation
-  results.hasKeyboardNavigation = uiFiles.some(file => 
-    file.content.includes('onKeyDown') || 
-    file.content.includes('onKeyPress')
-  );
-  
-  if (!results.hasKeyboardNavigation) {
-    results.issues.push('No keyboard navigation handlers found');
-  }
-  
-  // Check for semantic HTML
-  results.hasSemanticsHtml = uiFiles.some(file => 
-    file.content.includes('<nav') || 
-    file.content.includes('<main') || 
-    file.content.includes('<section') || 
-    file.content.includes('<article') || 
-    file.content.includes('<aside') || 
-    file.content.includes('<header') || 
-    file.content.includes('<footer')
-  );
-  
-  if (!results.hasSemanticsHtml) {
-    results.issues.push('No semantic HTML elements found');
-  }
-  
-  return results;
-}
-
-// Calculate overall score based on all checks
-function calculateScore(results) {
-  let score = 100;
-  
-  // Deduct for missing components
-  score -= results.completeness.missingComponents.length * 15;
-  
-  // Deduct for low test coverage
-  if (results.tests.coverage < 80) {
-    score -= (80 - results.tests.coverage) / 4;
-  }
-  
-  // Deduct for missing documentation
-  score -= results.documentation.missingDocs.length * 10;
-  
-  // Deduct for best practice violations
-  score -= results.bestPractices.violations.length * 5;
-  
-  // Deduct for accessibility issues (if applicable)
-  if (!results.accessibility.notApplicable) {
-    score -= results.accessibility.issues.length * 10;
-  }
-  
-  return Math.max(0, Math.round(score));
-}
-
-// Identify issues from all validation checks
-function identifyIssues(results) {
-  const issues = [];
-  
-  // Add missing components as issues
-  results.completeness.missingComponents.forEach(component => {
-    issues.push({
-      type: 'completeness',
-      severity: 'high',
-      message: `Missing ${component}`
-    });
-  });
-  
-  // Add test coverage issues
-  if (results.tests.coverage < 80) {
-    issues.push({
-      type: 'testing',
-      severity: 'high',
-      message: `Low test coverage (${Math.round(results.tests.coverage)}%)`
-    });
-  }
-  
-  results.tests.untested.forEach(func => {
-    issues.push({
-      type: 'testing',
-      severity: 'medium',
-      message: `Function "${func}" lacks tests`
-    });
-  });
-  
-  // Add documentation issues
-  results.documentation.missingDocs.forEach(doc => {
-    issues.push({
-      type: 'documentation',
-      severity: 'medium',
-      message: `Missing ${doc}`
-    });
-  });
-  
-  // Add best practice violations
-  results.bestPractices.violations.forEach(violation => {
-    issues.push({
-      type: 'best_practice',
-      severity: 'medium',
-      message: violation
-    });
-  });
-  
-  // Add accessibility issues
-  if (!results.accessibility.notApplicable) {
-    results.accessibility.issues.forEach(issue => {
-      issues.push({
-        type: 'accessibility',
-        severity: 'high',
-        message: issue
-      });
-    });
-  }
-  
-  return issues;
-}
-
-// Generate recommendations based on identified issues
-function generateRecommendations(issues) {
-  const recommendations = [];
-  
-  // Group issues by type
-  const issuesByType = {};
-  issues.forEach(issue => {
-    if (!issuesByType[issue.type]) {
-      issuesByType[issue.type] = [];
-    }
-    issuesByType[issue.type].push(issue);
-  });
-  
-  // Generate recommendations for completeness issues
-  if (issuesByType.completeness) {
-    recommendations.push({
-      type: 'completeness',
-      title: 'Complete the feature implementation',
-      steps: issuesByType.completeness.map(issue => issue.message.replace('Missing ', 'Add '))
-    });
-  }
-  
-  // Generate recommendations for testing issues
-  if (issuesByType.testing) {
-    recommendations.push({
-      type: 'testing',
-      title: 'Improve test coverage',
-      steps: [
-        'Write more unit tests for untested functions',
-        'Add integration tests for component interactions',
-        'Ensure all edge cases are covered'
-      ]
-    });
-  }
-  
-  // Generate recommendations for documentation issues
-  if (issuesByType.documentation) {
-    recommendations.push({
-      type: 'documentation',
-      title: 'Complete the documentation',
-      steps: issuesByType.documentation.map(issue => issue.message.replace('Missing ', 'Add '))
-    });
-  }
-  
-  // Generate recommendations for best practice issues
-  if (issuesByType.best_practice) {
-    recommendations.push({
-      type: 'best_practice',
-      title: 'Follow best practices',
-      steps: issuesByType.best_practice.map(issue => issue.message)
-    });
-  }
-  
-  // Generate recommendations for accessibility issues
-  if (issuesByType.accessibility) {
-    recommendations.push({
-      type: 'accessibility',
-      title: 'Improve accessibility',
-      steps: [
-        'Add appropriate ARIA attributes to UI components',
-        'Implement keyboard navigation for all interactive elements',
-        'Use semantic HTML elements to improve screen reader experience'
-      ]
-    });
-  }
-  
-  return recommendations;
-}
-
-// Generate a summary of the validation results
-function generateSummary(results) {
-  const score = results.score;
-  let status = '';
-  
-  if (score >= 90) {
-    status = 'EXCELLENT';
-  } else if (score >= 70) {
-    status = 'GOOD';
-  } else if (score >= 50) {
-    status = 'NEEDS IMPROVEMENT';
-  } else {
-    status = 'INCOMPLETE';
-  }
-  
-  return {
-    score,
-    status,
-    issues: results.issues.length,
-    critical: results.issues.filter(issue => issue.severity === 'high').length,
-    recommendations: results.recommendations.length,
-    message: generateSummaryMessage(score, status, results)
-  };
-}
-
-// Generate a summary message based on results
-function generateSummaryMessage(score, status, results) {
-  if (status === 'EXCELLENT') {
-    return 'Feature implementation meets or exceeds all quality standards. Good job!';
-  } else if (status === 'GOOD') {
-    return `Feature implementation is good overall but has ${results.issues.length} issues to address.`;
-  } else if (status === 'NEEDS IMPROVEMENT') {
-    const critical = results.issues.filter(issue => issue.severity === 'high').length;
-    return `Feature implementation needs significant improvement with ${critical} critical issues.`;
-  } else {
-    return 'Feature implementation is incomplete and does not meet minimum quality standards.';
-  }
-}
-
-// Helper function to extract functions from code
-function extractFunctions(content) {
-  const functions = [];
-  
-  // JavaScript/TypeScript functions
-  const jsMatches = content.match(/function\s+([a-zA-Z0-9_]+)\s*\([^)]*\)\s*\{/g) || [];
-  jsMatches.forEach(match => {
-    const name = match.match(/function\s+([a-zA-Z0-9_]+)/)[1];
-    const startIndex = content.indexOf(match);
-    const endIndex = findClosingBrace(content, startIndex + match.indexOf('{'));
-    const functionBody = content.substring(startIndex, endIndex + 1);
-    const lines = functionBody.split('\n').length;
-    
-    functions.push({ name, lines });
-  });
-  
-  // Java methods
-  const javaMatches = content.match(/public|private|protected\s+[a-zA-Z0-9_<>]+\s+([a-zA-Z0-9_]+)\s*\([^)]*\)\s*\{/g) || [];
-  javaMatches.forEach(match => {
-    const nameParts = match.match(/\s+([a-zA-Z0-9_]+)\s*\(/);
-    if (nameParts && nameParts[1]) {
-      const name = nameParts[1];
-      const startIndex = content.indexOf(match);
-      const endIndex = findClosingBrace(content, startIndex + match.indexOf('{'));
-      const functionBody = content.substring(startIndex, endIndex + 1);
-      const lines = functionBody.split('\n').length;
-      
-      functions.push({ name, lines });
-    }
-  });
-  
-  return functions;
-}
-
-// Helper function to find closing brace
-function findClosingBrace(content, openBraceIndex) {
-  let braceCount = 1;
-  for (let i = openBraceIndex + 1; i < content.length; i++) {
-    if (content[i] === '{') {
-      braceCount++;
-    } else if (content[i] === '}') {
-      braceCount--;
-      if (braceCount === 0) {
-        return i;
-      }
-    }
-  }
-  return content.length - 1;
-}
-
-// Helper function to identify feature type
-function identifyFeatureType(files) {
-  const uiFiles = files.filter(file => {
-    return (file.path.includes('.tsx') || file.path.includes('.jsx')) && 
-           (file.path.includes('component') || file.path.includes('page'));
-  });
-  
-  const apiFiles = files.filter(file => {
-    return (file.path.includes('controller') || file.path.includes('service')) && 
-           (file.path.includes('.java') || file.path.includes('.ts'));
-  });
-  
-  if (uiFiles.length > apiFiles.length) {
-    return 'ui';
-  } else if (apiFiles.length > 0) {
-    return 'api';
-  } else {
-    return 'other';
-  }
-}
-
-// Helper function to check for UI components
-function hasUiComponents(files) {
-  return files.some(file => {
-    return (file.path.includes('.tsx') || file.path.includes('.jsx')) && 
-           file.path.includes('component');
-  });
-}
-
-// Helper function to check for API endpoints
-function hasApiEndpoints(files) {
-  return files.some(file => {
-    return (file.path.includes('controller') || file.path.includes('route')) && 
-           (file.path.includes('.java') || file.path.includes('.ts'));
-  });
-}
-
-// Run on activation
-function activate(context) {
-  // Register event handlers
-  context.on('pull_request.created', (event) => {
-    const files = context.getPullRequestFiles(event.pullRequest.id);
-    const codebase = context.getCodebase();
-    return validateFeature(files, codebase, event.pullRequest);
-  });
-  
-  context.on('pull_request.updated', (event) => {
-    const files = context.getPullRequestFiles(event.pullRequest.id);
-    const codebase = context.getCodebase();
-    return validateFeature(files, codebase, event.pullRequest);
-  });
-  
-  context.on('pull_request.labeled:feature', (event) => {
-    const files = context.getPullRequestFiles(event.pullRequest.id);
-    const codebase = context.getCodebase();
-    return validateFeature(files, codebase, event.pullRequest);
-  });
-  
-  context.registerCommand('validate_feature', (args) => {
-    const prId = args.pullRequest;
-    if (!prId) {
-      return {
-        status: "error",
-        message: "No pull request specified"
-      };
-    }
-    
-    const files = context.getPullRequestFiles(prId);
-    const codebase = context.getCodebase();
-    const pullRequest = context.getPullRequest(prId);
-    return validateFeature(files, codebase, pullRequest);
-  });
-}
-
-// Export functions
-module.exports = {
-  activate,
-  validateFeature,
-  checkCompleteness,
-  checkTestCoverage,
-  checkDocumentation,
-  checkBestPractices,
-  checkAccessibility
-};
-```
-
-## When It Runs
-
-This rule can be triggered:
-- When a new feature pull request is created
-- When a pull request is updated
-- When a pull request is labeled with 'feature'
-- When a developer runs the `validate_feature` command in Cursor
-- Before merging feature implementation
-
-## Usage Example
-
-1. Create a pull request for a new feature
-2. Run `validate_feature --pullRequest=123` in Cursor
-3. Review the validation results
-4. Address any identified issues
-5. Re-run validation to confirm all issues are resolved
-
-## Feature Implementation Best Practices
-
-### Completeness Checklist
-
-- [ ] Implementation code
-- [ ] Comprehensive tests
-- [ ] User documentation
-- [ ] Developer documentation
-- [ ] API documentation (if applicable)
-
-### Testing Requirements
-
-- Unit tests for all functions/methods
-- Integration tests for component interactions
-- Functional tests for UI components
-- Edge case coverage
-- Minimum 80% test coverage
-
-### Documentation Guidelines
-
-- **User Documentation**: Explain how to use the feature
-- **Developer Documentation**: Explain how the feature is implemented
-- **API Documentation**: Document endpoints, parameters, and responses
\ No newline at end of file
diff --git a/.cursor/rules/verification/feature-verifier.mdc b/.cursor/rules/verification/feature-verifier.mdc
deleted file mode 100644
index 7c64749ee440..000000000000
--- a/.cursor/rules/verification/feature-verifier.mdc
+++ /dev/null
@@ -1,628 +0,0 @@
----
-description: 
-globs: 
-alwaysApply: true
----
- # Feature Implementation Verifier
-
-```yaml
-name: Feature Implementation Verifier
-description: Verifies that new features are properly implemented and tested
-author: Cursor AI
-version: 1.0.0
-tags:
-  - feature
-  - implementation
-  - verification
-  - acceptance-criteria
-activation:
-  always: true
-  event:
-    - pull_request
-    - command
-triggers:
-  - pull_request.created
-  - pull_request.updated
-  - pull_request.labeled:feature
-  - command: "verify_feature"
-```
-
-## Rule Definition
-
-This rule ensures that new feature implementations meet all requirements, follow best practices, and include appropriate tests.
-
-## Verification Logic
-
-```javascript
-// Main function to verify feature implementation
-function verifyFeatureImplementation(files, tests, requirements) {
-  const results = {
-    requirementsCoverage: checkRequirementsCoverage(files, requirements),
-    testCoverage: checkTestCoverage(files, tests),
-    codeQuality: checkCodeQuality(files),
-    documentation: checkDocumentation(files, requirements),
-    performance: checkPerformance(files),
-    score: 0,
-    issues: [],
-    recommendations: []
-  };
-  
-  // Calculate overall score
-  results.score = calculateScore(results);
-  
-  // Generate issues and recommendations
-  results.issues = identifyIssues(results);
-  results.recommendations = generateRecommendations(results.issues);
-  
-  return {
-    ...results,
-    summary: generateSummary(results)
-  };
-}
-
-// Check if all requirements are implemented
-function checkRequirementsCoverage(files, requirements) {
-  const results = {
-    implementedRequirements: [],
-    missingRequirements: [],
-    implementationRate: 0
-  };
-  
-  if (!requirements || requirements.length === 0) {
-    results.missingRequirements.push('requirements definition');
-    return results;
-  }
-  
-  // For each requirement, check if it's implemented
-  for (const req of requirements) {
-    const isImplemented = files.some(file => fileImplementsRequirement(file, req));
-    
-    if (isImplemented) {
-      results.implementedRequirements.push(req);
-    } else {
-      results.missingRequirements.push(req);
-    }
-  }
-  
-  results.implementationRate = requirements.length > 0 
-    ? (results.implementedRequirements.length / requirements.length) * 100 
-    : 0;
-  
-  return results;
-}
-
-// Helper to check if a file implements a specific requirement
-function fileImplementsRequirement(file, requirement) {
-  // This would contain complex analysis logic to match code to requirements
-  // For now, we'll use a simple text matching approach
-  return file.content.includes(requirement.id) || 
-         file.content.toLowerCase().includes(requirement.description.toLowerCase());
-}
-
-// Check if tests cover all the new functionality
-function checkTestCoverage(files, tests) {
-  const results = {
-    testedFiles: [],
-    untestedFiles: [],
-    coverage: 0
-  };
-  
-  if (!tests || tests.length === 0) {
-    files.forEach(file => {
-      if (shouldHaveTests(file)) {
-        results.untestedFiles.push(file.path);
-      }
-    });
-    
-    return results;
-  }
-  
-  // Check each file to see if it has test coverage
-  for (const file of files) {
-    const hasTests = tests.some(test => testCoversFile(test, file));
-    
-    if (hasTests || !shouldHaveTests(file)) {
-      results.testedFiles.push(file.path);
-    } else {
-      results.untestedFiles.push(file.path);
-    }
-  }
-  
-  const filesToTest = files.filter(file => shouldHaveTests(file)).length;
-  results.coverage = filesToTest > 0 
-    ? (results.testedFiles.length / filesToTest) * 100 
-    : 100;
-  
-  return results;
-}
-
-// Helper to determine if a test covers a specific file
-function testCoversFile(test, file) {
-  // This would contain complex analysis to determine test coverage
-  // For now, we'll use a simple path matching approach
-  const filePath = file.path.replace(/\.(js|ts|jsx|tsx|java)$/, '');
-  const testPath = test.path;
-  
-  return testPath.includes(filePath) || 
-         test.content.includes(file.path) || 
-         test.content.includes(filePath);
-}
-
-// Helper to determine if a file should have tests
-function shouldHaveTests(file) {
-  // Skip certain files that don't need tests
-  const skipPaths = [
-    'app/client/public/',
-    'app/client/src/assets/',
-    'app/client/src/styles/',
-    'app/client/src/constants/',
-    'app/client/src/types/'
-  ];
-  
-  if (skipPaths.some(path => file.path.includes(path))) {
-    return false;
-  }
-  
-  // Skip certain file types
-  const skipExtensions = ['.md', '.json', '.yml', '.yaml', '.svg', '.png', '.jpg'];
-  if (skipExtensions.some(ext => file.path.endsWith(ext))) {
-    return false;
-  }
-  
-  return true;
-}
-
-// Check the code quality of the implementation
-function checkCodeQuality(files) {
-  const results = {
-    qualityIssues: [],
-    issueCount: 0,
-    qualityScore: 100
-  };
-  
-  // Check each file for quality issues
-  for (const file of files) {
-    const fileIssues = analyzeCodeQuality(file);
-    
-    if (fileIssues.length > 0) {
-      results.qualityIssues.push({
-        file: file.path,
-        issues: fileIssues
-      });
-      
-      results.issueCount += fileIssues.length;
-      results.qualityScore -= Math.min(fileIssues.length * 5, 20); // Max 20 points deduction per file
-    }
-  }
-  
-  results.qualityScore = Math.max(0, results.qualityScore);
-  
-  return results;
-}
-
-// Helper to analyze code quality in a file
-function analyzeCodeQuality(file) {
-  const issues = [];
-  const content = file.content;
-  
-  // Check for common code quality issues
-  if (file.path.includes('.js') || file.path.includes('.ts')) {
-    // Check for console.log statements
-    if (content.includes('console.log')) {
-      issues.push({
-        type: 'debugging',
-        line: findLineForPattern(content, 'console.log'),
-        description: 'Remove console.log statements before committing'
-      });
-    }
-    
-    // Check for TODO comments
-    if (content.includes('TODO')) {
-      issues.push({
-        type: 'incomplete',
-        line: findLineForPattern(content, 'TODO'),
-        description: 'Resolve TODO comments before committing'
-      });
-    }
-    
-    // Check for commented out code
-    if (content.match(/\/\/\s*[a-zA-Z0-9]+/)) {
-      issues.push({
-        type: 'cleanliness',
-        line: findLineForPattern(content, '//'),
-        description: 'Remove commented out code before committing'
-      });
-    }
-  }
-  
-  // Check for proper indentation and formatting
-  const lines = content.split('\n');
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (line.length > 120) {
-      issues.push({
-        type: 'formatting',
-        line: i + 1,
-        description: 'Line exceeds 120 characters'
-      });
-    }
-    
-    // Check for inconsistent indentation
-    if (i > 0 && line.match(/^\s+/) && lines[i-1].match(/^\s+/)) {
-      const currentIndent = line.match(/^\s+/)[0].length;
-      const prevIndent = lines[i-1].match(/^\s+/)[0].length;
-      
-      if (Math.abs(currentIndent - prevIndent) % 2 !== 0 && Math.abs(currentIndent - prevIndent) !== 0) {
-        issues.push({
-          type: 'formatting',
-          line: i + 1,
-          description: 'Inconsistent indentation'
-        });
-      }
-    }
-  }
-  
-  return issues;
-}
-
-// Helper to find the line number for a pattern
-function findLineForPattern(content, pattern) {
-  const lines = content.split('\n');
-  for (let i = 0; i < lines.length; i++) {
-    if (lines[i].includes(pattern)) {
-      return i + 1;
-    }
-  }
-  return 1;
-}
-
-// Check for appropriate documentation
-function checkDocumentation(files, requirements) {
-  const results = {
-    documentedFiles: [],
-    undocumentedFiles: [],
-    documentationScore: 100
-  };
-  
-  // Check each file for documentation
-  for (const file of files) {
-    if (shouldHaveDocumentation(file)) {
-      if (hasAdequateDocumentation(file)) {
-        results.documentedFiles.push(file.path);
-      } else {
-        results.undocumentedFiles.push(file.path);
-        results.documentationScore -= 10; // 10 points deduction per undocumented file
-      }
-    }
-  }
-  
-  results.documentationScore = Math.max(0, results.documentationScore);
-  
-  return results;
-}
-
-// Helper to determine if a file should have documentation
-function shouldHaveDocumentation(file) {
-  // Public APIs, complex components, and services should have documentation
-  return file.path.includes('/api/') || 
-         file.path.includes('/services/') || 
-         file.path.includes('/components/') ||
-         file.path.endsWith('.java');
-}
-
-// Helper to check if a file has adequate documentation
-function hasAdequateDocumentation(file) {
-  const content = file.content;
-  
-  // Check for JSDoc, JavaDoc, or other documentation patterns
-  if (file.path.includes('.js') || file.path.includes('.ts')) {
-    return content.includes('/**') && content.includes('*/');
-  }
-  
-  if (file.path.includes('.java')) {
-    return content.includes('/**') && content.includes('*/') && content.includes('@param');
-  }
-  
-  // For other files, check for comment blocks
-  return content.includes('/*') && content.includes('*/');
-}
-
-// Check for performance implications
-function checkPerformance(files) {
-  // This would have comprehensive performance analysis
-  // For now, return an empty array for performance issues
-  return {
-    performanceIssues: [],
-    issueCount: 0
-  };
-}
-
-// Calculate overall score based on all checks
-function calculateScore(results) {
-  let score = 100;
-  
-  // Deduct for missing requirements
-  if (results.requirementsCoverage.implementationRate < 100) {
-    score -= (100 - results.requirementsCoverage.implementationRate) * 0.3;
-  }
-  
-  // Deduct for missing tests
-  if (results.testCoverage.coverage < 80) {
-    score -= (80 - results.testCoverage.coverage) * 0.3;
-  }
-  
-  // Deduct for code quality issues
-  score -= (100 - results.codeQuality.qualityScore) * 0.2;
-  
-  // Deduct for documentation issues
-  score -= (100 - results.documentation.documentationScore) * 0.2;
-  
-  return Math.max(0, Math.round(score));
-}
-
-// Identify issues from all verification checks
-function identifyIssues(results) {
-  const issues = [];
-  
-  // Add missing requirements as issues
-  results.requirementsCoverage.missingRequirements.forEach(req => {
-    issues.push({
-      type: 'requirements',
-      severity: 'high',
-      message: `Missing implementation for requirement: ${req.id || req}`
-    });
-  });
-  
-  // Add test coverage issues
-  if (results.testCoverage.untestedFiles.length > 0) {
-    issues.push({
-      type: 'testing',
-      severity: 'high',
-      message: `Missing tests for ${results.testCoverage.untestedFiles.length} files`
-    });
-    
-    results.testCoverage.untestedFiles.forEach(file => {
-      issues.push({
-        type: 'testing',
-        severity: 'medium',
-        message: `No tests for file: ${file}`
-      });
-    });
-  }
-  
-  // Add code quality issues
-  results.codeQuality.qualityIssues.forEach(fileIssue => {
-    fileIssue.issues.forEach(issue => {
-      issues.push({
-        type: 'code_quality',
-        severity: 'medium',
-        message: `${issue.description} in ${fileIssue.file} at line ${issue.line}`
-      });
-    });
-  });
-  
-  // Add documentation issues
-  results.documentation.undocumentedFiles.forEach(file => {
-    issues.push({
-      type: 'documentation',
-      severity: 'medium',
-      message: `Missing or inadequate documentation in ${file}`
-    });
-  });
-  
-  return issues;
-}
-
-// Generate recommendations based on identified issues
-function generateRecommendations(issues) {
-  const recommendations = [];
-  
-  // Group issues by type
-  const issuesByType = {};
-  issues.forEach(issue => {
-    if (!issuesByType[issue.type]) {
-      issuesByType[issue.type] = [];
-    }
-    issuesByType[issue.type].push(issue);
-  });
-  
-  // Generate recommendations for requirements issues
-  if (issuesByType.requirements) {
-    recommendations.push({
-      type: 'requirements',
-      title: 'Complete the implementation of requirements',
-      steps: [
-        'Review the missing requirements and ensure they are implemented',
-        'Verify that the implementation matches the acceptance criteria',
-        'Update the code to address all missing requirements'
-      ]
-    });
-  }
-  
-  // Generate recommendations for testing issues
-  if (issuesByType.testing) {
-    recommendations.push({
-      type: 'testing',
-      title: 'Improve test coverage',
-      steps: [
-        'Add unit tests for untested files',
-        'Create integration tests where appropriate',
-        'Ensure all edge cases are covered in tests'
-      ]
-    });
-  }
-  
-  // Generate recommendations for code quality issues
-  if (issuesByType.code_quality) {
-    recommendations.push({
-      type: 'code_quality',
-      title: 'Address code quality issues',
-      steps: [
-        'Remove debugging code (console.log, TODO comments)',
-        'Fix formatting and indentation issues',
-        'Follow project coding standards and best practices'
-      ]
-    });
-  }
-  
-  // Generate recommendations for documentation issues
-  if (issuesByType.documentation) {
-    recommendations.push({
-      type: 'documentation',
-      title: 'Improve documentation',
-      steps: [
-        'Add JSDoc or JavaDoc comments to public APIs and classes',
-        'Document complex components and their usage',
-        'Ensure all services have proper documentation'
-      ]
-    });
-  }
-  
-  return recommendations;
-}
-
-// Generate a summary of the verification results
-function generateSummary(results) {
-  const score = results.score;
-  let status = '';
-  
-  if (score >= 90) {
-    status = 'EXCELLENT';
-  } else if (score >= 70) {
-    status = 'GOOD';
-  } else if (score >= 50) {
-    status = 'NEEDS IMPROVEMENT';
-  } else {
-    status = 'INCOMPLETE';
-  }
-  
-  return {
-    score,
-    status,
-    issues: results.issues.length,
-    critical: results.issues.filter(issue => issue.severity === 'high').length,
-    recommendations: results.recommendations.length,
-    message: generateSummaryMessage(score, status, results)
-  };
-}
-
-// Generate a summary message based on results
-function generateSummaryMessage(score, status, results) {
-  if (status === 'EXCELLENT') {
-    return 'Feature implementation meets or exceeds all requirements and standards. Good job!';
-  } else if (status === 'GOOD') {
-    return `Feature implementation is good overall but has ${results.issues.length} issues to address.`;
-  } else if (status === 'NEEDS IMPROVEMENT') {
-    const critical = results.issues.filter(issue => issue.severity === 'high').length;
-    return `Feature implementation needs significant improvement with ${critical} critical issues.`;
-  } else {
-    return 'Feature implementation is incomplete and does not meet minimum requirements.';
-  }
-}
-
-// Run on activation
-function activate(context) {
-  // Register event handlers
-  context.on('pull_request.created', (event) => {
-    const files = context.getPullRequestFiles(event.pullRequest.id);
-    const tests = context.getPullRequestTests(event.pullRequest.id);
-    const requirements = context.getFeatureRequirements(event.pullRequest);
-    return verifyFeatureImplementation(files, tests, requirements);
-  });
-  
-  context.on('pull_request.updated', (event) => {
-    const files = context.getPullRequestFiles(event.pullRequest.id);
-    const tests = context.getPullRequestTests(event.pullRequest.id);
-    const requirements = context.getFeatureRequirements(event.pullRequest);
-    return verifyFeatureImplementation(files, tests, requirements);
-  });
-  
-  context.on('pull_request.labeled:feature', (event) => {
-    const files = context.getPullRequestFiles(event.pullRequest.id);
-    const tests = context.getPullRequestTests(event.pullRequest.id);
-    const requirements = context.getFeatureRequirements(event.pullRequest);
-    return verifyFeatureImplementation(files, tests, requirements);
-  });
-  
-  context.registerCommand('verify_feature', (args) => {
-    const prId = args.pullRequest;
-    if (!prId) {
-      return {
-        status: "error",
-        message: "No pull request specified"
-      };
-    }
-    
-    const files = context.getPullRequestFiles(prId);
-    const tests = context.getPullRequestTests(prId);
-    const requirements = context.getFeatureRequirements({ id: prId });
-    return verifyFeatureImplementation(files, tests, requirements);
-  });
-}
-
-// Export functions
-module.exports = {
-  activate,
-  verifyFeatureImplementation,
-  checkRequirementsCoverage,
-  checkTestCoverage,
-  checkCodeQuality,
-  checkDocumentation,
-  checkPerformance
-};
-```
-
-## When It Runs
-
-This rule can be triggered:
-- When a new feature pull request is created
-- When a pull request is updated
-- When a pull request is labeled with 'feature'
-- When a developer runs the `verify_feature` command in Cursor
-- Before merging a feature implementation
-
-## Usage Example
-
-1. Create a pull request for a new feature
-2. Run `verify_feature --pullRequest=123` in Cursor
-3. Review the verification results
-4. Address any identified issues
-5. Re-run verification to confirm all issues are resolved
-
-## Feature Implementation Checklist
-
-### Requirements
-- [ ] Understand the feature requirements and acceptance criteria
-- [ ] Design a solution that meets all requirements
-- [ ] Create a plan for implementing the feature
-- [ ] Consider edge cases and potential issues
-
-### Implementation
-- [ ] Follow the project's coding standards and architecture
-- [ ] Write clean, efficient, and maintainable code
-- [ ] Handle errors and edge cases gracefully
-- [ ] Ensure the feature integrates well with existing functionality
-
-### Testing
-- [ ] Write unit tests for all components
-- [ ] Create integration tests for complex interactions
-- [ ] Test across different environments if applicable
-- [ ] Verify that the feature meets all acceptance criteria
-
-### Review
-- [ ] Self-review the code before submission
-- [ ] Address feedback from automated checks
-- [ ] Ensure documentation is complete and accurate
-- [ ] Verify test coverage is adequate
-
-## Example: Verifying Acceptance Criteria
-
-For a file upload feature, the verifier would check for:
-
-- UI components for selecting files
-- Upload progress indicators
-- Success and error states
-- Backend API for handling file uploads
-- File validation and error handling
-- Tests for valid and invalid uploads
-- Performance considerations for large files
\ No newline at end of file
diff --git a/.cursor/rules/verification/workflow-validator.mdc b/.cursor/rules/verification/workflow-validator.mdc
deleted file mode 100644
index 7f05cafdf840..000000000000
--- a/.cursor/rules/verification/workflow-validator.mdc
+++ /dev/null
@@ -1,253 +0,0 @@
----
-description: 
-globs: 
-alwaysApply: true
----
- # Workflow Configuration Validator
-
-```yaml
-name: Workflow Configuration Validator
-description: Validates GitHub workflow files before commits and pushes
-author: Cursor AI
-version: 1.0.0
-tags:
-  - ci
-  - workflows
-  - quality-checks
-  - validation
-activation:
-  always: true
-  events:
-    - pre_commit
-    - pre_push
-    - command
-triggers:
-  - pre_commit
-  - pre_push
-  - command: "validate_workflows"
-```
-
-## Rule Definition
-
-This rule ensures that GitHub workflow configuration files (especially `.github/workflows/quality-checks.yml`) are valid before allowing commits or pushes.
-
-## Validation Logic
-
-```javascript
-const yaml = require('js-yaml');
-const fs = require('fs');
-const { execSync } = require('child_process');
-
-/**
- * Main function to validate GitHub workflow files
- * @param {Object} context - The execution context
- * @returns {Object} Validation results
- */
-function validateWorkflows(context) {
-  const results = {
-    isValid: true,
-    errors: [],
-    warnings: []
-  };
-  
-  // Primary focus: quality-checks.yml
-  const qualityChecksPath = '.github/workflows/quality-checks.yml';
-  
-  try {
-    // Check if file exists
-    if (!fs.existsSync(qualityChecksPath)) {
-      results.errors.push(`${qualityChecksPath} file does not exist`);
-      results.isValid = false;
-      return results;
-    }
-    
-    // Check if file is valid YAML
-    try {
-      const fileContents = fs.readFileSync(qualityChecksPath, 'utf8');
-      const parsedYaml = yaml.load(fileContents);
-      
-      // Check for required fields in workflow
-      if (!parsedYaml.name) {
-        results.warnings.push(`${qualityChecksPath} is missing a name field`);
-      }
-      
-      if (!parsedYaml.jobs || Object.keys(parsedYaml.jobs).length === 0) {
-        results.errors.push(`${qualityChecksPath} doesn't contain any jobs`);
-        results.isValid = false;
-      }
-      
-      // Check for common GitHub Actions workflow validation
-      if (context.hasCommand('gh')) {
-        try {
-          // Use GitHub CLI to validate workflow if available
-          execSync(`gh workflow view ${qualityChecksPath} --json`, { stdio: 'pipe' });
-        } catch (error) {
-          results.errors.push(`GitHub CLI validation failed: ${error.message}`);
-          results.isValid = false;
-        }
-      } else {
-        // Basic structural validation if GitHub CLI is not available
-        const requiredKeys = ['on', 'jobs'];
-        for (const key of requiredKeys) {
-          if (!parsedYaml[key]) {
-            results.errors.push(`${qualityChecksPath} is missing required key: ${key}`);
-            results.isValid = false;
-          }
-        }
-      }
-      
-      // Check for other workflows
-      const workflowsDir = '.github/workflows';
-      if (fs.existsSync(workflowsDir)) {
-        const workflowFiles = fs.readdirSync(workflowsDir)
-          .filter(file => file.endsWith('.yml') || file.endsWith('.yaml'));
-        
-        // Validate all workflow files
-        for (const file of workflowFiles) {
-          if (file === 'quality-checks.yml') continue; // Already checked
-          
-          const filePath = `${workflowsDir}/${file}`;
-          try {
-            const contents = fs.readFileSync(filePath, 'utf8');
-            yaml.load(contents); // Just check if it's valid YAML
-          } catch (e) {
-            results.errors.push(`${filePath} contains invalid YAML: ${e.message}`);
-            results.isValid = false;
-          }
-        }
-      }
-    } catch (e) {
-      results.errors.push(`Failed to parse ${qualityChecksPath}: ${e.message}`);
-      results.isValid = false;
-    }
-  } catch (error) {
-    results.errors.push(`General error validating workflows: ${error.message}`);
-    results.isValid = false;
-  }
-  
-  return results;
-}
-
-/**
- * Check if workflow files have been modified in the current changes
- * @param {Object} context - The execution context
- * @returns {boolean} Whether workflow files have been modified
- */
-function haveWorkflowsChanged(context) {
-  try {
-    const gitStatus = execSync('git diff --name-only --cached', { encoding: 'utf8' });
-    const changedFiles = gitStatus.split('\n').filter(Boolean);
-    
-    return changedFiles.some(file => 
-      file.startsWith('.github/workflows/') && 
-      (file.endsWith('.yml') || file.endsWith('.yaml'))
-    );
-  } catch (error) {
-    // If we can't determine if workflows changed, assume they did to be safe
-    return true;
-  }
-}
-
-/**
- * Run the validation when triggered
- * @param {Object} context - The execution context
- * @returns {Object} The action result
- */
-function onTrigger(context, event) {
-  // For pre-commit and pre-push, only validate if workflow files have changed
-  if ((event === 'pre_commit' || event === 'pre_push') && !haveWorkflowsChanged(context)) {
-    return {
-      status: 'success',
-      message: 'No workflow files changed, skipping validation'
-    };
-  }
-  
-  const results = validateWorkflows(context);
-  
-  if (!results.isValid) {
-    return {
-      status: 'failure',
-      message: 'Workflow validation failed',
-      details: results.errors.join('\n'),
-      warnings: results.warnings.join('\n')
-    };
-  }
-  
-  return {
-    status: 'success',
-    message: 'All workflow files are valid',
-    warnings: results.warnings.length ? results.warnings.join('\n') : undefined
-  };
-}
-
-/**
- * Register command and hooks
- * @param {Object} context - The cursor context
- */
-function activate(context) {
-  // Register pre-commit hook
-  context.on('pre_commit', (event) => {
-    return onTrigger(context, 'pre_commit');
-  });
-  
-  // Register pre-push hook
-  context.on('pre_push', (event) => {
-    return onTrigger(context, 'pre_push');
-  });
-  
-  // Register command for manual validation
-  context.registerCommand('validate_workflows', () => {
-    return onTrigger(context, 'command');
-  });
-}
-
-module.exports = {
-  activate,
-  validateWorkflows
-};
-```
-
-## Usage
-
-This rule runs automatically on pre-commit and pre-push events. You can also manually trigger it with the command `validate_workflows`.
-
-### Pre-Commit Hook
-
-When committing changes, this rule will:
-1. Check if any workflow files were modified
-2. If so, validate that `.github/workflows/quality-checks.yml` is properly formatted
-3. Block the commit if validation fails
-
-### Examples
-
-**Valid Workflow:**
-```yaml
-name: Quality Checks
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-jobs:
-  lint:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Run linters
-        run: |
-          npm ci
-          npm run lint
-```
-
-**Invalid Workflow (Will Fail Validation):**
-```yaml
-on:
-  push:
-jobs:
-  lint:
-    # Missing "runs-on" field
-    steps:
-      - uses: actions/checkout@v3
-      - name: Run linters
-        run: npm run lint
-```
\ No newline at end of file
diff --git a/.cursor/rules/workflow-ci.mdc b/.cursor/rules/workflow-ci.mdc
new file mode 100644
index 000000000000..29b8444ca935
--- /dev/null
+++ b/.cursor/rules/workflow-ci.mdc
@@ -0,0 +1,39 @@
+---
+description:
+globs: .github/workflows/**/*.yml,.github/workflows/**/*.yaml
+alwaysApply: false
+---
+# GitHub Workflow Conventions
+
+## Validation
+
+When editing workflow files, ensure:
+
+- Valid YAML syntax
+- Required top-level keys: `on`, `jobs` (`name` is optional)
+- Every job has a `runs-on` field
+- Action versions are pinned (e.g., `actions/checkout@v4`, not `@main`)
+
+## Key Workflows
+
+| Workflow | Purpose |
+|----------|---------|
+| `client-build.yml` | Client build pipeline |
+| `server-build.yml` | Server build pipeline |
+| `ci-test-limited.yml` | CI test suite |
+| `client-unit-tests.yml` | Client unit tests |
+| `server-integration-tests.yml` | Server integration tests |
+
+## Testing Locally Before Push
+
+```bash
+# Server
+cd app/server && mvn spotless:check          # Formatting
+cd app/server && mvn test                    # Unit tests
+
+# Client
+cd app/client && yarn lint                   # ESLint
+cd app/client && yarn prettier               # Prettier
+cd app/client && yarn test:unit              # Jest
+cd app/client && yarn check-types            # TypeScript
+```
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 000000000000..49ba2bfe5f48
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,86 @@
+# Appsmith Project Conventions
+
+## Codebase Structure
+
+- **Frontend**: `app/client/` — React 18, TypeScript, Redux + Redux-Saga, styled-components
+- **Backend**: `app/server/` — Java 25, Spring Boot 3.5, Spring WebFlux (reactive), MongoDB, Maven
+- **E2E Tests**: `app/client/cypress/` — Cypress 13
+- **CI/CD**: `.github/workflows/`
+- **Infrastructure**: `deploy/`
+
+## CE-EE Architecture (Critical)
+
+Appsmith has a Community Edition (CE) and Enterprise Edition (EE). This repo is CE. EE is a private superset that syncs from CE hourly.
+
+### Three-Layer Model
+
+Every extensible service/component follows: **CE → CE-Compatible → EE**
+
+- **CE layer** (`*.ce` package / `src/ce/` directory): Base open-source implementation. Contains all core logic.
+- **CE-Compatible layer** (`*.ce_compatible` package): Graceful degradation layer. When an enterprise license expires, resources created with paid features remain accessible in read-only mode through this layer. In CE repo, these are empty pass-throughs.
+- **EE layer** (parent package / `src/ee/` directory): Enterprise overrides. Methods annotated with `@FeatureFlagged`. In CE repo, EE files are thin stubs that re-export from CE.
+
+### Feature Flag Dispatch (Spring AOP)
+
+`@FeatureFlagged(featureFlagName = FeatureFlagEnum.XXX)` on EE methods. The `FeatureFlaggedMethodInvokerAspect` (`@Around` advice) checks the flag:
+- **Flag ON** → executes the EE method
+- **Flag OFF** → reflectively invokes the superclass (CE-Compatible) method
+- If CE-Compatible doesn't override → falls through to CE base
+
+Flags are evaluated per-organization (cached) with user-level fallback (Flagsmith). Organization flags take precedence.
+
+### Backend CE-EE Pattern
+
+```text
+Interface: ServiceCE → ServiceCECompatible → Service
+Impl:      ServiceCEImpl → ServiceCECompatibleImpl → ServiceImpl (@Service)
+```
+
+- `@Service` annotation on CE-Compatible and final `*Impl` classes (not on CE base classes)
+- Constructor-based DI exclusively (no field injection)
+- CE impl holds all business logic; final impl is a pass-through in CE repo
+- This pattern applies to services, repositories, controllers, solutions, domains, DTOs
+
+### Frontend CE-EE Pattern
+
+- `app/client/src/ce/` — real implementations (306+ files)
+- `app/client/src/ee/` — re-export stubs in CE: `export * from "ce/..."`
+- **Always import from `"ee/..."`, never from `"ce/"` directly** (enforced by ESLint restricted-imports)
+- TypeScript path alias in `tsconfig.path.json`: `"ee/*": ["ee/*"]`
+- Frontend feature flags: `useFeatureFlag(flagName)` hook from `"utils/hooks/useFeatureFlag"`
+
+### When Creating New Features
+
+- New service? Create full CE → CE-Compatible → EE chain
+- New frontend module? Create `ce/` implementation + `ee/` re-export stub
+- New feature flag? Add to `FeatureFlagEnum` (server) and `FeatureFlag` (client)
+- Extension point for EE? Use `protected` methods in CE impl that EE can override
+
+## Git & PR Conventions
+
+- Branch naming: `fix/fix-name`, `feature/feature-name`
+- PR titles: Conventional Commits format — `type(scope): description`
+- Valid types: `feat`, `fix`, `docs`, `style`, `refactor`, `perf`, `test`, `build`, `ci`, `chore`, `revert`
+- Scope is optional but recommended
+- Commit messages: verb-prefixed ("Add ...", "Fix ...", "Update ...", "Remove ..."), with issue reference when applicable
+
+## Pre-existing Automation
+
+- **Husky pre-commit**: When server files are staged, runs `mvn spotless:apply`. When client files are staged, runs `lint-staged` (eslint --fix --cache + prettier --write --cache). All files get `gitleaks` secret scanning. Skipped for merge commits.
+- **Husky pre-push**: Blocks pushing `app/client/src/ee` files to CE remote
+- Do not manually run formatting before commit — Husky handles it.
+
+## Build & Verify Commands
+
+```bash
+# Server
+cd app/server && mvn spotless:apply          # Format Java code
+cd app/server && mvn spotless:check          # Check formatting
+cd app/server && ./build.sh -DskipTests      # Build without tests
+
+# Client
+cd app/client && yarn lint                   # ESLint check
+cd app/client && yarn prettier               # Prettier check
+cd app/client && yarn test:unit              # Jest unit tests
+cd app/client && yarn check-types            # TypeScript type-check
+```
diff --git a/app/client/CLAUDE.md b/app/client/CLAUDE.md
new file mode 100644
index 000000000000..aa300d17251a
--- /dev/null
+++ b/app/client/CLAUDE.md
@@ -0,0 +1,57 @@
+# React / TypeScript Frontend Conventions
+
+## Tech Stack
+
+- React 18, TypeScript (strict mode), Redux + Redux-Saga, styled-components
+- Build: Webpack, Yarn 3 (Berry) with workspaces
+- Linting: ESLint (Airbnb-based) + Prettier (80 cols, 2-space, double quotes, trailing commas)
+
+## CE-EE Import Pattern (Critical)
+
+- **Always import from `"ee/..."`, never from `"ce/"` directly** (enforced by ESLint)
+- `app/client/src/ce/` — real CE implementations; `app/client/src/ee/` — re-export stubs
+- TypeScript path alias: `"ee/*": ["ee/*"]` in `tsconfig.path.json`
+- New modules: create `ce/` implementation + matching `ee/` re-export stub
+- Feature flags: `useFeatureFlag(flagName)` hook from `"utils/hooks/useFeatureFlag"`
+
+## Component Conventions
+
+- Functional components with hooks exclusively
+- Props: `interface` for extendable shapes (preferred), `type` for unions
+- `any` is banned (`@typescript-eslint/no-explicit-any: "error"`)
+- `import type` enforced for type-only imports
+
+## Styling
+
+- **styled-components** primary; CSS Modules secondary (WDS widgets)
+- Design tokens: `--ads-v2-*` (design system), `--color-*` (WDS). No Tailwind.
+
+## State Management
+
+- Redux handler-map pattern via `createReducer(initialState, handlers)` — not switch-case, not Redux Toolkit
+- Action types in `ce/constants/ReduxActionConstants.tsx`: `_INIT`, `_SUCCESS`, `_ERROR`
+- Sagas with `takeLatest`/`takeEvery`/`debounce` in `yield all([...])`
+- Selectors: plain functions + `createSelector` from reselect
+
+## API Calls
+
+- Axios exclusively. Base URL: `/api/`. Response: `ApiResponse<T>` envelope.
+- Legacy class-based `Api` + newer functional `apiFactory()` in `api/core/`
+
+## ESLint Rules
+
+- `no-console: "error"`, `react/jsx-sort-props: "error"`
+- `@appsmith/named-use-effect` — useEffect must receive named functions
+- `@appsmith/object-keys` — use `objectKeys()` not `Object.keys()`
+- Restricted imports: `**/ce/*`, `codemirror`, `lottie-web`, `@uppy/*`
+
+## File Naming
+
+- Components: PascalCase. Utilities: camelCase. Tests: `<name>.test.ts(x)`
+- Hybrid structure: by-type top-level + by-feature for domains
+
+## Commands
+
+```bash
+yarn lint && yarn prettier && yarn test:unit && yarn check-types
+```
diff --git a/app/client/cypress/CLAUDE.md b/app/client/cypress/CLAUDE.md
new file mode 100644
index 000000000000..d196910d0553
--- /dev/null
+++ b/app/client/cypress/CLAUDE.md
@@ -0,0 +1,52 @@
+# Cypress E2E Test Conventions
+
+## Framework
+
+- Cypress 13 with `testIsolation: false` (tests share state within a spec)
+- Viewport: 1400x1200. Timeouts: 30s default, 60s request/response.
+
+## Page Object Pattern (Mandatory)
+
+Import from `ObjectsCore.ts` — do NOT use raw `cy.get()` for common operations:
+
+```typescript
+import { agHelper, locators, dataSources, deployMode } from "../../../../support/Objects/ObjectsCore";
+```
+
+Key objects: `agHelper` (central utility), `locators` (selectors), `dataSources`, `deployMode`, `homePage`, `jsEditor`, `propPane`.
+
+## Selector Strategy
+
+1. `t--` CSS classes (dominant): `.t--application-publish-btn`
+2. `data-testid` (growing): `data-testid="t--git-connect-next"`
+3. `data-widgetname-cy` (widget-specific)
+
+Centralized in `cypress/locators/` (44 files) + `CommonLocators.ts`.
+
+## Test Structure
+
+- File naming: `FeatureName_Spec.ts` (capital S). Bug tests: `Bug14987_spec.js`
+- Numbered `it` blocks (sequential, shared state): `it("1. Setup...", ...)`, `it("2. Action...", ...)`
+- Tags: `{ tags: ["@tag.Widget", "@tag.Input"] }` for `@cypress/grep` filtering
+
+## Setup / Teardown
+
+- Global: API-based login (`cy.LoginFromAPI()`), workspace + app creation
+- Per-spec: `agHelper.AddDsl("dslName")` to load widget fixtures
+- Cleanup: delete entities in final `it` block or `after()` hook
+
+## API Intercepts
+
+Spy-style (not stubs). All tests run against real backend:
+
+```typescript
+cy.intercept("POST", "/api/v1/datasources/test").as("testDatasource");
+cy.wait("@testDatasource");
+```
+
+## Running Tests
+
+```bash
+npx cypress run --spec <spec-path>     # Specific spec
+npx cypress open                       # Interactive mode
+```
diff --git a/app/server/CLAUDE.md b/app/server/CLAUDE.md
new file mode 100644
index 000000000000..bb8a923c6395
--- /dev/null
+++ b/app/server/CLAUDE.md
@@ -0,0 +1,81 @@
+# Java / Spring Boot Backend Conventions
+
+## Tech Stack
+
+- Java 25, Spring Boot 3.5, Spring WebFlux (fully reactive), MongoDB, Maven
+- Formatting: Palantir Java Format via `mvn spotless:apply` (auto-runs on pre-commit)
+
+## CE-EE Service Pattern (Mandatory for all extensible components)
+
+### Three-tier inheritance
+
+```text
+Interface: ServiceCE            → ServiceCECompatible            → Service
+Impl:      ServiceCEImpl        → ServiceCECompatibleImpl        → ServiceImpl (@Service)
+Package:   com.x.services.ce      com.x.services.ce_compatible     com.x.services
+```
+
+- `@Service` / `@Component` annotation on CE-Compatible and final `*Impl` classes (not on CE base classes)
+- Constructor-based DI exclusively (no field injection), use `@RequiredArgsConstructor`
+- CE impl contains all business logic; final impl is a pass-through in CE repo
+- CE-Compatible: empty pass-through in CE (EE overrides for graceful degradation when license expires)
+- Always create the CE-Compatible layer even if no EE override exists yet
+- Use `protected` methods in CE impl to create override hooks for EE
+- This pattern applies to: services, repositories, controllers, solutions, helpers, configurations, domains, DTOs
+
+## Controller Conventions
+
+- CE class (in `controllers/ce/`): all endpoint logic, NOT annotated as `@RestController`
+- EE class (in `controllers/`): `@RestController` + `@RequestMapping`, empty body, extends CE
+- URL paths: `/api/v1/{resource}` — constants in `UrlCE.java`
+- Response: always `Mono<ResponseDTO<T>>`; `@JsonView(Views.Public.class)` on every endpoint
+- Zero business logic — delegate to services. No error handling — global `@ControllerAdvice`
+
+## Repository Conventions
+
+- ACL-aware queries via `queryBuilder()` fluent API with `Bridge` criteria
+- No `@Query` annotations — use `Bridge` query builder exclusively
+- Field references via `@FieldNameConstants` (`Fields` inner class)
+- Soft deletes: `archive()` sets `deletedAt`; queries auto-filter
+
+## Domain / DTO Conventions
+
+- `@Getter`, `@Setter`, `@ToString` — **not** `@Data`
+- `@FieldNameConstants` on all domains/DTOs
+- `@JsonView` controls API visibility (`Views.Public.class`, `Views.Internal.class`)
+- `@Transient` for computed fields; domains follow CE-EE split (`ActionDTO extends ActionCE_DTO`)
+
+## Reactive Patterns
+
+All service methods return `Mono<T>` or `Flux<T>`. Never `.block()` in production code.
+- `.switchIfEmpty(Mono.error(...))` for not-found; `Mono.cache()` to prevent duplicate subscriptions
+- `Mono.zip()` / `.zipWhen()` for parallel/dependent ops; `Mono.defer()` for lazy eval
+- `.onErrorResume()` for degradation; `.onErrorMap()` to translate to `AppsmithException`
+
+## Error Handling
+
+- `AppsmithException(AppsmithError.SOME_ERROR, args...)` — 100+ errors with HTTP status + error code
+- Global `GlobalExceptionHandler` catches and returns `ResponseDTO<ErrorDTO>`
+
+## Feature Flags
+
+- `@FeatureFlagged(featureFlagName = FeatureFlagEnum.XXX)` on EE methods
+- AOP dispatches: flag ON → EE method; flag OFF → superclass (CE-Compatible/CE)
+- Sync methods need `organizationId` param; flags evaluated per-org with user fallback
+- New flags: add to `FeatureFlagEnum` in `appsmith-interfaces`
+
+## Running a Single Test
+
+```bash
+cd app/server && source envs/test.env.example && mvn test -pl appsmith-server -Dtest=ClassName
+```
+
+Docker must be running. Unit tests use embedded MongoDB (Flapdoodle) — do NOT start local MongoDB.
+
+## Build Commands
+
+```bash
+cd app/server && mvn spotless:apply                    # Format code
+cd app/server && ./build.sh -DskipTests                # Build without tests
+cd app/server && ./build.sh -DskipTests -T 8           # Build (8 threads)
+```