[feat] Extend organizations (multi-orgs, verified domains, sso providers)

AGENTS.md

@@ -377,6 +377,119 @@ export const createItemAtom = atom(
 
 ---
 
+### Entity Controller Pattern
+
+For entities requiring CRUD operations with draft state, loading indicators, and cache management, use the **Entity Controller Pattern**. This provides a unified API that abstracts multiple atoms into a single cohesive interface.
+
+**Full documentation:** `web/oss/src/state/entities/shared/README.md`
+
+**Quick Decision - Which API to Use:**
+
+| Need | API | Returns |
+|------|-----|---------|
+| Full state + actions | `entity.controller(id)` | `[state, dispatch]` |
+| Data only | `entity.selectors.data(id)` | `T \| null` |
+| Loading/error | `entity.selectors.query(id)` | `QueryState<T>` |
+| Dirty indicator | `entity.selectors.isDirty(id)` | `boolean` |
+| Single cell (tables) | `entity.selectors.cell({id, col})` | `unknown` |
+| Dispatch in atoms | `entity.actions.update/discard` | Write atom |
+
+**Basic Usage:**
+
+```typescript
+import {testcase} from "@/oss/state/entities/testcase"
+
+// Full controller - state + dispatch
+function TestcaseEditor({testcaseId}: {testcaseId: string}) {
+  const [state, dispatch] = useAtom(testcase.controller(testcaseId))
+
+  if (state.isPending) return <Skeleton />
+  if (!state.data) return <NotFound />
+
+  return (
+    <Input
+      value={state.data.input}
+      onChange={(e) => dispatch({
+        type: "update",
+        changes: {input: e.target.value}
+      })}
+    />
+  )
+}
+
+// Fine-grained selector - only re-renders on data change
+function TestcaseDisplay({testcaseId}: {testcaseId: string}) {
+  const data = useAtomValue(testcase.selectors.data(testcaseId))
+  if (!data) return null
+  return <div>{data.input}</div>
+}
+```
+
+**Reading Multiple Entities:**
+
+```typescript
+// Create a derived atom that subscribes to all selected entities
+const useMultipleTestcases = (ids: string[]) => {
+  const dataAtom = useMemo(
+    () => atom((get) => ids.map(id => get(testcase.selectors.data(id))).filter(Boolean)),
+    [ids.join(",")]
+  )
+  return useAtomValue(dataAtom)
+}
+```
+
+**Anti-Patterns to Avoid:**
+
+```typescript
+// BAD - No reactivity, snapshot read
+const globalStore = getDefaultStore()
+const data = globalStore.get(testcase.selectors.data(id))
+
+// GOOD - Proper subscription
+const data = useAtomValue(testcase.selectors.data(id))
+```
+
+```typescript
+// BAD - Variable shadowing
+import {testcase} from "@/oss/state/entities/testcase"
+const {testcase, ...rest} = entity  // Shadows import!
+
+// GOOD - Rename destructured variable
+const {testcase: testcaseField, ...rest} = entity
+```
+
+**Available Controllers:**
+
+| Entity | Import | Description |
+|--------|--------|-------------|
+| Testcase | `testcase` from `@/oss/state/entities/testcase` | Testcase with cell subscriptions + drill-in |
+| Trace Span | `traceSpan` from `@/oss/state/entities/trace` | Trace span with attribute drill-in |
+| Revision | `revision` from `@/oss/state/entities/testset` | Revision with column management |
+| Testset | `testset` from `@/oss/state/entities/testset` | Testset with list/detail queries |
+
+**Architecture:**
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                       Controller                                 │
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐              │
+│  │   Query     │  │   Draft     │  │   isDirty   │              │
+│  │ (server)    │→ │  (local)    │→ │  (derived)  │              │
+│  └─────────────┘  └─────────────┘  └─────────────┘              │
+│         ↓               ↓                                        │
+│  ┌─────────────────────────────────────────────────────────────┐│
+│  │                 Entity Atom (merged)                        ││
+│  └─────────────────────────────────────────────────────────────┘│
+└─────────────────────────────────────────────────────────────────┘
+```
+
+- **Query atoms** are the single source of truth for server data
+- **Draft atoms** store local changes only
+- **Entity atoms** merge: `query.data + draft → merged entity`
+- **Dirty detection** compares draft to server data
+
+---
+
 **Legacy: SWR Pattern (avoid for new code)**
 
 We previously used SWR with Axios for data fetching. This pattern is still present in older code but should not be used for new features.

CLAUDE.md

@@ -0,0 +1,7 @@
+# Instructions for Claude
+
+Please read and follow all instructions in:
+
+@AGENTS.md
+
+Project conventions, guidelines, and best practices are documented there.

api/ee/databases/postgres/migrations/core/data_migrations/evaluators.py

@@ -38,8 +38,8 @@
 )
 
 # Redis client and TracingWorker for publishing spans to Redis Streams
-if env.REDIS_URI_DURABLE:
-    redis_client = Redis.from_url(env.REDIS_URI_DURABLE, decode_responses=False)
+if env.redis.uri_durable:
+    redis_client = Redis.from_url(env.redis.uri_durable, decode_responses=False)
     tracing_worker = TracingWorker(
         service=tracing_service,
         redis_client=redis_client,
@@ -81,9 +81,10 @@ async def _fetch_project_owner(
             WorkspaceMemberDBE.role == "owner",
             ProjectDBE.id == project_id,
         )
+        .order_by(WorkspaceMemberDBE.created_at.asc())
     )
     result = await connection.execute(workspace_owner_query)
-    owner = result.scalar_one_or_none()
+    owner = result.scalars().first()
     return owner
 
 

api/ee/databases/postgres/migrations/core/data_migrations/testsets.py

@@ -69,9 +69,10 @@ async def _fetch_project_owner(
             WorkspaceMemberDBE.role == "owner",
             ProjectDBE.id == project_id,
         )
+        .order_by(WorkspaceMemberDBE.created_at.asc())
     )
     result = await connection.execute(workspace_owner_query)
-    owner = result.scalar_one_or_none()
+    owner = result.scalars().first()
     return owner
 
 

api/ee/databases/postgres/migrations/core/data_migrations/workspaces.py

@@ -28,7 +28,7 @@ def get_or_create_workspace_default_project(
 
     if project is None:
         statement = insert(ProjectDB).values(
-            project_name="Default Project",
+            project_name="Default",
             is_default=True,
             workspace_id=workspace.id,
             organization_id=workspace.organization_id,

api/ee/databases/postgres/migrations/core/utils.py

@@ -118,7 +118,9 @@ async def get_pending_migration_head():
 
 def run_alembic_migration():
     """
-    Applies migration for first-time users and also checks the environment variable "AGENTA_AUTO_MIGRATIONS" to determine whether to apply migrations for returning users.
+    Applies migration for first-time users and also checks the environment variable
+    "ALEMBIC_AUTO_MIGRATIONS" (legacy: "AGENTA_AUTO_MIGRATIONS") to determine whether
+    to apply migrations for returning users.
     """
 
     try:

api/ee/databases/postgres/migrations/core/versions/12d23a8f7dde_add_slug_to_organizations.py

@@ -0,0 +1,51 @@
+"""add slug to organizations
+
+Revision ID: 12d23a8f7dde
+Revises: 59b85eb7516c
+Create Date: 2025-12-25 00:00:00.000000+00:00
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+# revision identifiers, used by Alembic.
+revision: str = "12d23a8f7dde"
+down_revision: Union[str, None] = "59b85eb7516c"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # Add slug column to organizations table
+    op.add_column(
+        "organizations",
+        sa.Column(
+            "slug",
+            sa.String(),
+            nullable=True,
+        ),
+    )
+
+    # Add unique constraint on slug
+    op.create_unique_constraint(
+        "uq_organizations_slug",
+        "organizations",
+        ["slug"],
+    )
+
+    # Add index for faster lookups
+    op.create_index(
+        "ix_organizations_slug",
+        "organizations",
+        ["slug"],
+    )
+
+
+def downgrade() -> None:
+    # Drop in reverse order
+    op.drop_index("ix_organizations_slug", table_name="organizations")
+    op.drop_constraint("uq_organizations_slug", "organizations", type_="unique")
+    op.drop_column("organizations", "slug")