M1: OrgBoard — organizations, teams, seats, the board & cartable

OrgBoard module (references SharedKernel only; RBAC via ICurrentUser/IPermissionService): - Organization, Team, Seat (human/open/ai), WorkItem (board task: type, status, assignee, parent) entities; internal OrgBoardDbContext (schema "orgboard") + InitialOrgBoard migration; design-time factory. (WorkItem avoids the System.Threading.Tasks.Task clash.) - Endpoints under /api/orgboard, every mutation permission-checked at the scope chain [team, org]: POST /organizations, POST/GET /teams, POST /tasks, GET /board (columns backlog->in progress->in review->done), PATCH /tasks/{id}/move, /assign, GET /cartable. Test isolation: integration tests now use IClassFixture so each class gets its own pgvector container (the bootstrap-once rule made a shared container collide). Verified: build green; ArchitectureTests 8/8 (OrgBoard references only SharedKernel); IntegrationTests 12/12 incl. a new board flow — owner sets up org+team, creates/moves/ assigns a task, sees it on the board and in the cartable; an invited Member can view the board but is 403'd from creating a team. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-06-09 11:58:20 +03:30
parent 61991bf6cd
commit e1911f58b1
18 changed files with 1137 additions and 23 deletions
@@ -0,0 +1,34 @@
+namespace TeamUp.Modules.OrgBoard.Domain;
+
+/// <summary>The seat-state triad — the load-bearing concept of the UI (human / open / AI).</summary>
+internal enum SeatState
+{
+    Human,
+    Open,
+    Ai,
+}
+
+internal enum WorkItemType
+{
+    Spec,
+    Story,
+    Test,
+    Review,
+    Release,
+}
+
+/// <summary>The board columns: backlog → in progress → in review → done.</summary>
+internal enum WorkItemStatus
+{
+    Backlog,
+    InProgress,
+    InReview,
+    Done,
+}
+
+internal enum AssigneeKind
+{
+    Unassigned,
+    Member,
+    Agent,
+}
@@ -0,0 +1,23 @@
+using TeamUp.SharedKernel.Domain;
+
+namespace TeamUp.Modules.OrgBoard.Domain;
+
+/// <summary>The company. Its id is the Organization scope that org-level memberships are granted at.</summary>
+internal sealed class Organization : Entity
+{
+    public string Name { get; private set; } = null!;
+    public DateTimeOffset CreatedAtUtc { get; private set; }
+
+    private Organization()
+    {
+    }
+
+    public Organization(Guid id, string name, DateTimeOffset createdAtUtc)
+    {
+        Id = id;
+        Name = name;
+        CreatedAtUtc = createdAtUtc;
+    }
+
+    public void Rename(string name) => Name = name;
+}
@@ -0,0 +1,41 @@
+using TeamUp.SharedKernel.Domain;
+
+namespace TeamUp.Modules.OrgBoard.Domain;
+
+/// <summary>A role on a team, in one of three states: human / open / AI. AI seats are configured in M3.</summary>
+internal sealed class Seat : Entity
+{
+    public Guid TeamId { get; private set; }
+    public string RoleName { get; private set; } = null!;
+    public SeatState State { get; private set; }
+    public Guid? MemberId { get; private set; }
+    public Guid? AgentId { get; private set; }
+    public DateTimeOffset CreatedAtUtc { get; private set; }
+
+    private Seat()
+    {
+    }
+
+    public Seat(Guid teamId, string roleName, SeatState state, DateTimeOffset createdAtUtc, Guid? memberId = null)
+    {
+        TeamId = teamId;
+        RoleName = roleName;
+        State = state;
+        MemberId = memberId;
+        CreatedAtUtc = createdAtUtc;
+    }
+
+    public void AssignMember(Guid memberId)
+    {
+        MemberId = memberId;
+        AgentId = null;
+        State = SeatState.Human;
+    }
+
+    public void Open()
+    {
+        MemberId = null;
+        AgentId = null;
+        State = SeatState.Open;
+    }
+}
@@ -0,0 +1,22 @@
+using TeamUp.SharedKernel.Domain;
+
+namespace TeamUp.Modules.OrgBoard.Domain;
+
+/// <summary>A team within an organization. Team-level memberships are granted at its id (Team scope).</summary>
+internal sealed class Team : Entity
+{
+    public Guid OrganizationId { get; private set; }
+    public string Name { get; private set; } = null!;
+    public DateTimeOffset CreatedAtUtc { get; private set; }
+
+    private Team()
+    {
+    }
+
+    public Team(Guid organizationId, string name, DateTimeOffset createdAtUtc)
+    {
+        OrganizationId = organizationId;
+        Name = name;
+        CreatedAtUtc = createdAtUtc;
+    }
+}
@@ -0,0 +1,64 @@
+using TeamUp.SharedKernel.Domain;
+
+namespace TeamUp.Modules.OrgBoard.Domain;
+
+/// <summary>A board task. Humans and AI share this one model — the assignee is a member or an agent.</summary>
+internal sealed class WorkItem : Entity
+{
+    public Guid TeamId { get; private set; }
+    public string Title { get; private set; } = null!;
+    public string? Description { get; private set; }
+    public WorkItemType Type { get; private set; }
+    public WorkItemStatus Status { get; private set; }
+    public AssigneeKind AssigneeKind { get; private set; }
+    public Guid? AssigneeId { get; private set; }
+    public Guid? ParentId { get; private set; }
+    public Guid CreatedByMemberId { get; private set; }
+    public DateTimeOffset CreatedAtUtc { get; private set; }
+    public DateTimeOffset UpdatedAtUtc { get; private set; }
+
+    private WorkItem()
+    {
+    }
+
+    public WorkItem(
+        Guid teamId,
+        string title,
+        string? description,
+        WorkItemType type,
+        Guid createdByMemberId,
+        DateTimeOffset nowUtc,
+        Guid? parentId = null)
+    {
+        TeamId = teamId;
+        Title = title;
+        Description = description;
+        Type = type;
+        Status = WorkItemStatus.Backlog;
+        AssigneeKind = AssigneeKind.Unassigned;
+        CreatedByMemberId = createdByMemberId;
+        ParentId = parentId;
+        CreatedAtUtc = nowUtc;
+        UpdatedAtUtc = nowUtc;
+    }
+
+    public void MoveTo(WorkItemStatus status, DateTimeOffset nowUtc)
+    {
+        Status = status;
+        UpdatedAtUtc = nowUtc;
+    }
+
+    public void AssignToMember(Guid memberId, DateTimeOffset nowUtc)
+    {
+        AssigneeKind = AssigneeKind.Member;
+        AssigneeId = memberId;
+        UpdatedAtUtc = nowUtc;
+    }
+
+    public void Unassign(DateTimeOffset nowUtc)
+    {
+        AssigneeKind = AssigneeKind.Unassigned;
+        AssigneeId = null;
+        UpdatedAtUtc = nowUtc;
+    }
+}
@@ -0,0 +1,32 @@
+using TeamUp.Modules.OrgBoard.Domain;
+
+namespace TeamUp.Modules.OrgBoard.Endpoints;
+
+internal sealed record CreateOrganizationRequest(Guid OrganizationId, string Name);
+
+internal sealed record OrganizationResponse(Guid Id, string Name);
+
+internal sealed record CreateTeamRequest(Guid OrganizationId, string Name);
+
+internal sealed record TeamResponse(Guid Id, Guid OrganizationId, string Name);
+
+internal sealed record CreateTaskRequest(Guid TeamId, string Title, string? Description, WorkItemType Type);
+
+internal sealed record MoveTaskRequest(WorkItemStatus Status);
+
+internal sealed record AssignTaskRequest(Guid MemberId);
+
+internal sealed record TaskResponse(
+    Guid Id,
+    Guid TeamId,
+    string Title,
+    string? Description,
+    string Type,
+    string Status,
+    string AssigneeKind,
+    Guid? AssigneeId,
+    Guid? ParentId);
+
+internal sealed record BoardColumn(string Status, IReadOnlyList<TaskResponse> Items);
+
+internal sealed record BoardResponse(Guid TeamId, IReadOnlyList<BoardColumn> Columns);
@@ -0,0 +1,223 @@
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+using Microsoft.EntityFrameworkCore;
+using TeamUp.Modules.OrgBoard.Domain;
+using TeamUp.Modules.OrgBoard.Persistence;
+using TeamUp.SharedKernel.Access;
+using TeamUp.SharedKernel.Modularity;
+
+namespace TeamUp.Modules.OrgBoard.Endpoints;
+
+internal static class OrgBoardEndpoints
+{
+    public static void Map(IEndpointRouteBuilder endpoints)
+    {
+        var group = endpoints.MapGroup("/api/orgboard").WithTags("OrgBoard");
+
+        group.MapGet("/ping", () => TypedResults.Ok(new ModulePing("orgboard")));
+        group.MapPost("/organizations", CreateOrganization).RequireAuthorization();
+        group.MapPost("/teams", CreateTeam).RequireAuthorization();
+        group.MapGet("/teams", ListTeams).RequireAuthorization();
+        group.MapPost("/tasks", CreateTask).RequireAuthorization();
+        group.MapGet("/board", GetBoard).RequireAuthorization();
+        group.MapPatch("/tasks/{id:guid}/move", MoveTask).RequireAuthorization();
+        group.MapPatch("/tasks/{id:guid}/assign", AssignTask).RequireAuthorization();
+        group.MapGet("/cartable", Cartable).RequireAuthorization();
+    }
+
+    private static TaskResponse ToResponse(WorkItem item) => new(
+        item.Id, item.TeamId, item.Title, item.Description,
+        item.Type.ToString(), item.Status.ToString(), item.AssigneeKind.ToString(),
+        item.AssigneeId, item.ParentId);
+
+    private static async Task<IResult> CreateOrganization(
+        CreateOrganizationRequest request, IPermissionService permissions,
+        OrgBoardDbContext db, TimeProvider clock, CancellationToken ct)
+    {
+        if (!permissions.Has(Capability.CreateProductsAndTeams, ScopeRef.Org(request.OrganizationId)))
+        {
+            return Results.Forbid();
+        }
+
+        if (string.IsNullOrWhiteSpace(request.Name))
+        {
+            return Results.BadRequest("Name is required.");
+        }
+
+        var organization = await db.Organizations.FirstOrDefaultAsync(o => o.Id == request.OrganizationId, ct);
+        if (organization is null)
+        {
+            organization = new Organization(request.OrganizationId, request.Name.Trim(), clock.GetUtcNow());
+            db.Organizations.Add(organization);
+        }
+        else
+        {
+            organization.Rename(request.Name.Trim());
+        }
+
+        await db.SaveChangesAsync(ct);
+        return Results.Ok(new OrganizationResponse(organization.Id, organization.Name));
+    }
+
+    private static async Task<IResult> CreateTeam(
+        CreateTeamRequest request, IPermissionService permissions,
+        OrgBoardDbContext db, TimeProvider clock, CancellationToken ct)
+    {
+        if (!permissions.Has(Capability.CreateProductsAndTeams, ScopeRef.Org(request.OrganizationId)))
+        {
+            return Results.Forbid();
+        }
+
+        if (string.IsNullOrWhiteSpace(request.Name))
+        {
+            return Results.BadRequest("Name is required.");
+        }
+
+        if (!await db.Organizations.AnyAsync(o => o.Id == request.OrganizationId, ct))
+        {
+            return Results.BadRequest("Organization does not exist; create it first.");
+        }
+
+        var team = new Team(request.OrganizationId, request.Name.Trim(), clock.GetUtcNow());
+        db.Teams.Add(team);
+        await db.SaveChangesAsync(ct);
+        return Results.Ok(new TeamResponse(team.Id, team.OrganizationId, team.Name));
+    }
+
+    private static async Task<IResult> ListTeams(
+        Guid organizationId, IPermissionService permissions, OrgBoardDbContext db, CancellationToken ct)
+    {
+        if (!permissions.Has(Capability.ViewBoard, ScopeRef.Org(organizationId)))
+        {
+            return Results.Forbid();
+        }
+
+        var teams = await db.Teams
+            .Where(t => t.OrganizationId == organizationId)
+            .OrderBy(t => t.CreatedAtUtc)
+            .Select(t => new TeamResponse(t.Id, t.OrganizationId, t.Name))
+            .ToListAsync(ct);
+
+        return Results.Ok(teams);
+    }
+
+    private static async Task<IResult> CreateTask(
+        CreateTaskRequest request, ICurrentUser user, IPermissionService permissions,
+        OrgBoardDbContext db, TimeProvider clock, CancellationToken ct)
+    {
+        var team = await db.Teams.FirstOrDefaultAsync(t => t.Id == request.TeamId, ct);
+        if (team is null)
+        {
+            return Results.NotFound("Team not found.");
+        }
+
+        if (!permissions.Has(Capability.WorkTasks, ScopeRef.Team(team.Id), ScopeRef.Org(team.OrganizationId)))
+        {
+            return Results.Forbid();
+        }
+
+        if (string.IsNullOrWhiteSpace(request.Title))
+        {
+            return Results.BadRequest("Title is required.");
+        }
+
+        var item = new WorkItem(team.Id, request.Title.Trim(), request.Description, request.Type, user.MemberId, clock.GetUtcNow());
+        db.WorkItems.Add(item);
+        await db.SaveChangesAsync(ct);
+        return Results.Ok(ToResponse(item));
+    }
+
+    private static async Task<IResult> GetBoard(
+        Guid teamId, IPermissionService permissions, OrgBoardDbContext db, CancellationToken ct)
+    {
+        var team = await db.Teams.FirstOrDefaultAsync(t => t.Id == teamId, ct);
+        if (team is null)
+        {
+            return Results.NotFound("Team not found.");
+        }
+
+        if (!permissions.Has(Capability.ViewBoard, ScopeRef.Team(team.Id), ScopeRef.Org(team.OrganizationId)))
+        {
+            return Results.Forbid();
+        }
+
+        var items = await db.WorkItems.Where(w => w.TeamId == teamId).OrderBy(w => w.CreatedAtUtc).ToListAsync(ct);
+        var columns = Enum.GetValues<WorkItemStatus>()
+            .Select(status => new BoardColumn(
+                status.ToString(),
+                items.Where(i => i.Status == status).Select(ToResponse).ToList()))
+            .ToList();
+
+        return Results.Ok(new BoardResponse(teamId, columns));
+    }
+
+    private static async Task<IResult> MoveTask(
+        Guid id, MoveTaskRequest request, IPermissionService permissions,
+        OrgBoardDbContext db, TimeProvider clock, CancellationToken ct)
+    {
+        var (item, team, error) = await LoadItemWithTeam(db, id, ct);
+        if (error is not null)
+        {
+            return error;
+        }
+
+        if (!permissions.Has(Capability.WorkTasks, ScopeRef.Team(team!.Id), ScopeRef.Org(team.OrganizationId)))
+        {
+            return Results.Forbid();
+        }
+
+        item!.MoveTo(request.Status, clock.GetUtcNow());
+        await db.SaveChangesAsync(ct);
+        return Results.Ok(ToResponse(item));
+    }
+
+    private static async Task<IResult> AssignTask(
+        Guid id, AssignTaskRequest request, IPermissionService permissions,
+        OrgBoardDbContext db, TimeProvider clock, CancellationToken ct)
+    {
+        var (item, team, error) = await LoadItemWithTeam(db, id, ct);
+        if (error is not null)
+        {
+            return error;
+        }
+
+        if (!permissions.Has(Capability.WorkTasks, ScopeRef.Team(team!.Id), ScopeRef.Org(team.OrganizationId)))
+        {
+            return Results.Forbid();
+        }
+
+        item!.AssignToMember(request.MemberId, clock.GetUtcNow());
+        await db.SaveChangesAsync(ct);
+        return Results.Ok(ToResponse(item));
+    }
+
+    private static async Task<IResult> Cartable(ICurrentUser user, OrgBoardDbContext db, CancellationToken ct)
+    {
+        var memberId = user.MemberId;
+        var items = await db.WorkItems
+            .Where(w => w.AssigneeKind == AssigneeKind.Member && w.AssigneeId == memberId)
+            .OrderByDescending(w => w.UpdatedAtUtc)
+            .ToListAsync(ct);
+
+        return Results.Ok(items.Select(ToResponse).ToList());
+    }
+
+    private static async Task<(WorkItem? Item, Team? Team, IResult? Error)> LoadItemWithTeam(
+        OrgBoardDbContext db, Guid itemId, CancellationToken ct)
+    {
+        var item = await db.WorkItems.FirstOrDefaultAsync(w => w.Id == itemId, ct);
+        if (item is null)
+        {
+            return (null, null, Results.NotFound("Task not found."));
+        }
+
+        var team = await db.Teams.FirstOrDefaultAsync(t => t.Id == item.TeamId, ct);
+        if (team is null)
+        {
+            return (null, null, Results.NotFound("Team not found."));
+        }
+
+        return (item, team, null);
+    }
+}
@@ -1,9 +1,12 @@
-using Microsoft.AspNetCore.Builder;
-using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Routing;
+using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using TeamUp.Modules.OrgBoard.Endpoints;
+using TeamUp.Modules.OrgBoard.Persistence;
 using TeamUp.SharedKernel.Modularity;
+using TeamUp.SharedKernel.Persistence;

 namespace TeamUp.Modules.OrgBoard;

@@ -14,14 +17,13 @@ public sealed class OrgBoardModule : IModule

    public void Register(IServiceCollection services, IConfiguration configuration)
    {
-        // Skeleton: no services yet. M1 introduces this module's (internal) DbContext,
-        // FluentValidation validators, and domain services here.
+        var connectionString = configuration.GetConnectionString("Postgres")
+            ?? throw new InvalidOperationException("Missing connection string 'ConnectionStrings:Postgres'.");
+
+        services.AddDbContext<OrgBoardDbContext>(options => options.UseNpgsql(connectionString));
+        services.AddScoped<IModuleDbContext>(sp => sp.GetRequiredService<OrgBoardDbContext>());
+        services.TryAddSingleton(TimeProvider.System);
    }

-    public void MapEndpoints(IEndpointRouteBuilder endpoints)
-    {
-        endpoints.MapGroup($"/api/{Name}")
-            .WithTags("OrgBoard")
-            .MapGet("/ping", () => TypedResults.Ok(new ModulePing(Name)));
-    }
+    public void MapEndpoints(IEndpointRouteBuilder endpoints) => OrgBoardEndpoints.Map(endpoints);
 }
@@ -0,0 +1,165 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using TeamUp.Modules.OrgBoard.Persistence;
+
+#nullable disable
+
+namespace TeamUp.Modules.OrgBoard.Persistence.Migrations
+{
+    [DbContext(typeof(OrgBoardDbContext))]
+    [Migration("20260609043906_InitialOrgBoard")]
+    partial class InitialOrgBoard
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasDefaultSchema("orgboard")
+                .HasAnnotation("ProductVersion", "10.0.8")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("TeamUp.Modules.OrgBoard.Domain.Organization", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("organizations", "orgboard");
+                });
+
+            modelBuilder.Entity("TeamUp.Modules.OrgBoard.Domain.Seat", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("AgentId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("MemberId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("RoleName")
+                        .IsRequired()
+                        .HasMaxLength(120)
+                        .HasColumnType("character varying(120)");
+
+                    b.Property<string>("State")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("character varying(16)");
+
+                    b.Property<Guid>("TeamId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TeamId");
+
+                    b.ToTable("seats", "orgboard");
+                });
+
+            modelBuilder.Entity("TeamUp.Modules.OrgBoard.Domain.Team", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<Guid>("OrganizationId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrganizationId");
+
+                    b.ToTable("teams", "orgboard");
+                });
+
+            modelBuilder.Entity("TeamUp.Modules.OrgBoard.Domain.WorkItem", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("AssigneeId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AssigneeKind")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("character varying(16)");
+
+                    b.Property<DateTimeOffset>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("CreatedByMemberId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("ParentId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("character varying(16)");
+
+                    b.Property<Guid>("TeamId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(300)
+                        .HasColumnType("character varying(300)");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("character varying(16)");
+
+                    b.Property<DateTimeOffset>("UpdatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TeamId");
+
+                    b.HasIndex("AssigneeKind", "AssigneeId");
+
+                    b.ToTable("work_items", "orgboard");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
@@ -0,0 +1,132 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace TeamUp.Modules.OrgBoard.Persistence.Migrations
+{
+    /// <inheritdoc />
+    public partial class InitialOrgBoard : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.EnsureSchema(
+                name: "orgboard");
+
+            migrationBuilder.CreateTable(
+                name: "organizations",
+                schema: "orgboard",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uuid", nullable: false),
+                    Name = table.Column<string>(type: "character varying(200)", maxLength: 200, nullable: false),
+                    CreatedAtUtc = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_organizations", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "seats",
+                schema: "orgboard",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uuid", nullable: false),
+                    TeamId = table.Column<Guid>(type: "uuid", nullable: false),
+                    RoleName = table.Column<string>(type: "character varying(120)", maxLength: 120, nullable: false),
+                    State = table.Column<string>(type: "character varying(16)", maxLength: 16, nullable: false),
+                    MemberId = table.Column<Guid>(type: "uuid", nullable: true),
+                    AgentId = table.Column<Guid>(type: "uuid", nullable: true),
+                    CreatedAtUtc = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_seats", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "teams",
+                schema: "orgboard",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uuid", nullable: false),
+                    OrganizationId = table.Column<Guid>(type: "uuid", nullable: false),
+                    Name = table.Column<string>(type: "character varying(200)", maxLength: 200, nullable: false),
+                    CreatedAtUtc = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_teams", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "work_items",
+                schema: "orgboard",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uuid", nullable: false),
+                    TeamId = table.Column<Guid>(type: "uuid", nullable: false),
+                    Title = table.Column<string>(type: "character varying(300)", maxLength: 300, nullable: false),
+                    Description = table.Column<string>(type: "text", nullable: true),
+                    Type = table.Column<string>(type: "character varying(16)", maxLength: 16, nullable: false),
+                    Status = table.Column<string>(type: "character varying(16)", maxLength: 16, nullable: false),
+                    AssigneeKind = table.Column<string>(type: "character varying(16)", maxLength: 16, nullable: false),
+                    AssigneeId = table.Column<Guid>(type: "uuid", nullable: true),
+                    ParentId = table.Column<Guid>(type: "uuid", nullable: true),
+                    CreatedByMemberId = table.Column<Guid>(type: "uuid", nullable: false),
+                    CreatedAtUtc = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false),
+                    UpdatedAtUtc = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_work_items", x => x.Id);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_seats_TeamId",
+                schema: "orgboard",
+                table: "seats",
+                column: "TeamId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_teams_OrganizationId",
+                schema: "orgboard",
+                table: "teams",
+                column: "OrganizationId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_work_items_AssigneeKind_AssigneeId",
+                schema: "orgboard",
+                table: "work_items",
+                columns: new[] { "AssigneeKind", "AssigneeId" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_work_items_TeamId",
+                schema: "orgboard",
+                table: "work_items",
+                column: "TeamId");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "organizations",
+                schema: "orgboard");
+
+            migrationBuilder.DropTable(
+                name: "seats",
+                schema: "orgboard");
+
+            migrationBuilder.DropTable(
+                name: "teams",
+                schema: "orgboard");
+
+            migrationBuilder.DropTable(
+                name: "work_items",
+                schema: "orgboard");
+        }
+    }
+}
@@ -0,0 +1,162 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using TeamUp.Modules.OrgBoard.Persistence;
+
+#nullable disable
+
+namespace TeamUp.Modules.OrgBoard.Persistence.Migrations
+{
+    [DbContext(typeof(OrgBoardDbContext))]
+    partial class OrgBoardDbContextModelSnapshot : ModelSnapshot
+    {
+        protected override void BuildModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasDefaultSchema("orgboard")
+                .HasAnnotation("ProductVersion", "10.0.8")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("TeamUp.Modules.OrgBoard.Domain.Organization", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("organizations", "orgboard");
+                });
+
+            modelBuilder.Entity("TeamUp.Modules.OrgBoard.Domain.Seat", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("AgentId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("MemberId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("RoleName")
+                        .IsRequired()
+                        .HasMaxLength(120)
+                        .HasColumnType("character varying(120)");
+
+                    b.Property<string>("State")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("character varying(16)");
+
+                    b.Property<Guid>("TeamId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TeamId");
+
+                    b.ToTable("seats", "orgboard");
+                });
+
+            modelBuilder.Entity("TeamUp.Modules.OrgBoard.Domain.Team", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<Guid>("OrganizationId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OrganizationId");
+
+                    b.ToTable("teams", "orgboard");
+                });
+
+            modelBuilder.Entity("TeamUp.Modules.OrgBoard.Domain.WorkItem", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("AssigneeId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AssigneeKind")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("character varying(16)");
+
+                    b.Property<DateTimeOffset>("CreatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("CreatedByMemberId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("ParentId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("character varying(16)");
+
+                    b.Property<Guid>("TeamId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(300)
+                        .HasColumnType("character varying(300)");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("character varying(16)");
+
+                    b.Property<DateTimeOffset>("UpdatedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TeamId");
+
+                    b.HasIndex("AssigneeKind", "AssigneeId");
+
+                    b.ToTable("work_items", "orgboard");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
@@ -0,0 +1,55 @@
+using Microsoft.EntityFrameworkCore;
+using TeamUp.Modules.OrgBoard.Domain;
+using TeamUp.SharedKernel.Persistence;
+
+namespace TeamUp.Modules.OrgBoard.Persistence;
+
+internal sealed class OrgBoardDbContext(DbContextOptions<OrgBoardDbContext> options)
+    : DbContext(options), IModuleDbContext
+{
+    public DbSet<Organization> Organizations => Set<Organization>();
+    public DbSet<Team> Teams => Set<Team>();
+    public DbSet<Seat> Seats => Set<Seat>();
+    public DbSet<WorkItem> WorkItems => Set<WorkItem>();
+
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        modelBuilder.HasDefaultSchema("orgboard");
+
+        modelBuilder.Entity<Organization>(organization =>
+        {
+            organization.ToTable("organizations");
+            organization.HasKey(o => o.Id);
+            organization.Property(o => o.Name).HasMaxLength(200).IsRequired();
+        });
+
+        modelBuilder.Entity<Team>(team =>
+        {
+            team.ToTable("teams");
+            team.HasKey(t => t.Id);
+            team.Property(t => t.Name).HasMaxLength(200).IsRequired();
+            team.HasIndex(t => t.OrganizationId);
+        });
+
+        modelBuilder.Entity<Seat>(seat =>
+        {
+            seat.ToTable("seats");
+            seat.HasKey(s => s.Id);
+            seat.Property(s => s.RoleName).HasMaxLength(120).IsRequired();
+            seat.Property(s => s.State).HasConversion<string>().HasMaxLength(16);
+            seat.HasIndex(s => s.TeamId);
+        });
+
+        modelBuilder.Entity<WorkItem>(workItem =>
+        {
+            workItem.ToTable("work_items");
+            workItem.HasKey(w => w.Id);
+            workItem.Property(w => w.Title).HasMaxLength(300).IsRequired();
+            workItem.Property(w => w.Type).HasConversion<string>().HasMaxLength(16);
+            workItem.Property(w => w.Status).HasConversion<string>().HasMaxLength(16);
+            workItem.Property(w => w.AssigneeKind).HasConversion<string>().HasMaxLength(16);
+            workItem.HasIndex(w => w.TeamId);
+            workItem.HasIndex(w => new { w.AssigneeKind, w.AssigneeId });
+        });
+    }
+}
@@ -0,0 +1,21 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Design;
+
+namespace TeamUp.Modules.OrgBoard.Persistence;
+
+/// <summary>Design-time factory so `dotnet ef` can build the internal context without a host.</summary>
+internal sealed class OrgBoardDbContextFactory : IDesignTimeDbContextFactory<OrgBoardDbContext>
+{
+    public OrgBoardDbContext CreateDbContext(string[] args)
+    {
+        var connectionString =
+            Environment.GetEnvironmentVariable("ConnectionStrings__Postgres")
+            ?? "Host=localhost;Port=5432;Database=teamup;Username=teamup;Password=teamup";
+
+        var options = new DbContextOptionsBuilder<OrgBoardDbContext>()
+            .UseNpgsql(connectionString)
+            .Options;
+
+        return new OrgBoardDbContext(options);
+    }
+}
@@ -1,10 +1,17 @@
 <Project Sdk="Microsoft.NET.Sdk">

-  <!-- A self-contained module. References SharedKernel ONLY (ASP.NET flows transitively for the
-       IModule seam). M1 adds this module's EF/Npgsql/FluentValidation/Mapperly packages when it
-       gains an (internal) DbContext and validators. It must never reference another module. -->
+  <!-- Org, products, teams, seats, and the task/board model (M1). References SharedKernel only;
+       permission checks use ICurrentUser/IPermissionService from SharedKernel (implemented by
+       Identity), so OrgBoard never references another module. -->
  <ItemGroup>
    <ProjectReference Include="..\..\Shared\TeamUp.SharedKernel\TeamUp.SharedKernel.csproj" />
  </ItemGroup>

+  <ItemGroup>
+    <PackageReference Include="Microsoft.EntityFrameworkCore" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" PrivateAssets="all" />
+    <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" />
+    <PackageReference Include="FluentValidation" />
+  </ItemGroup>
+
 </Project>