diff --git a/AGENTS.md b/AGENTS.md
index 8cd2500..7fc0b11 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -10,8 +10,8 @@ What the app is and how to run it: [`README.md`](README.md). UI rules: [`docs/de
   `openid-client`. ID tokens are signature-checked. Tokens remain in the dedicated Redis server session store.
   `src/start.ts` validates the configured Origin on all state-changing requests. There is no Better Auth proxy.
 - **Server functions** attach `adminMiddleware` for reads, and their exact permission middleware for mutations:
-  grants, Telegram groups, WhatsApp groups, labels, website content, reports, and Microsoft 365 member creation and
-  member-number changes.
+  grants, Telegram groups, WhatsApp groups, labels, website content, reports, People (write, appoint, link, team), and
+  Microsoft 365 member creation and member-number changes.
   The backend independently checks every procedure. `context.backend` forwards a bearer token, never cookies.
 - **Features** (`src/features/<area>/`): pages, dialogs, validation and `*.functions.ts` server functions.
 - **Microsoft 365**: read the member directory with `azure:members:read` and create with `azure:members:create` through
@@ -23,12 +23,16 @@ What the app is and how to run it: [`README.md`](README.md). UI rules: [`docs/de
   the Socio role, so adding or removing anyone in a group would grant or revoke IdP roles. Nothing else about users or
   groups can be edited from the dashboard.
 - **People** (`src/features/people/`): every page reads and writes through `peopleApi(context)`, which parses the
-  backend's `people.*` responses with `people.contract.ts` and, in agent mode, uses the in-memory fake
-  (`AGENT_PERMISSIONS`, `AGENT_PERSON` pick the viewer). `/dashboard` admits `people:self` without `admin:access`;
-  Capo Admin and Team Lead come from the person's own record (`peopleRoles` in the route context) and only open their
-  sections. Member register, Receipts, Census and My area's fee card are unconnected mockups (#138): static sample data
-  from `mockup-data.ts`, no server functions, disabled actions and a `MockupBanner`, gated by `people:read`, to be
-  rebuilt in Phase 2 (#144) and Phase 3 (#145). Handoff notes, decisions and the plan: `docs/people/`.
+  backend's `people.*` responses with `people.contract.ts` (a copy of the backend's) and, in agent mode, uses the
+  in-memory fake (`AGENT_PERMISSIONS`, `AGENT_PERSON` pick the viewer). A person's roles are assignments (Admin, Capo
+  Admin, team member or Lead, nothing else): `pending` until the record is linked to an account, then held by
+  PoliNetwork Auth, which may refuse a change; pages show each assignment's status and Auth's refusal word for word.
+  `people:write` edits records, admins and invites, `people:appoint` Capo Admins and Leads, `people:link` links and
+  unlinks by hand. `/dashboard` admits `people:self` without `admin:access`; Capo Admin and Team Lead come from the
+  person's own record (`peopleRoles` in the route context) and only open their sections. Member register, Receipts,
+  Census and My area's fee card are unconnected mockups (#138): static sample data from `mockup-data.ts`, no server
+  functions, disabled actions and a `MockupBanner`, gated by `people:read`, to be rebuilt in Phase 2 (#144) and
+  Phase 3 (#145). Handoff notes, decisions and the plan: `docs/people/`.
 - **Shared UI**: `src/components/shell`, `src/components/primitives`, `src/components/ui`.
 
 ## Conventions
diff --git a/docs/people/contract.md b/docs/people/contract.md
index 2310a1a..52d88d6 100644
--- a/docs/people/contract.md
+++ b/docs/people/contract.md
@@ -1,196 +1,81 @@
 # People area: backend contract
 
-The dashboard calls these procedures under `people.*` on the tRPC backend (`@polinetwork/backend`). They do not exist
-yet: this file is the spec for the backend project. **`src/features/people/people.contract.ts` is the source of
-truth** for every shape and input (zod schemas); where this file differs, the code wins. In agent mode the dashboard
-serves the same shapes from `src/features/people/people.fixtures.server.ts`.
-
-Every procedure checks permissions server-side; the "Needs" column is the minimum. Dates are ISO `YYYY-MM-DD` strings
-(`Europe/Rome`); timestamps ISO 8601.
-
-> [!IMPORTANT]
-> **Removed from the contract (#138).** Soci (the member register), fees and receipts, the census, record matching
-> and Telegram group tracking are no longer part of People. The dashboard no longer calls `people.members.*`,
-> `people.fees.*`, `people.receipts.*`, `people.census.*`, `people.linking.reviews` / `resolve` / `dismiss`,
-> `people.capo.approve` / `decline`, or `people.me.confirmMatch` / `rejectMatch` / `answerCensus` /
-> `requestCorrection` / `revokePhotoConsent` / `uploadTransferReceipt` / `receipt` / `askToBeAdded`, and the backend
-> drops them in PoliNetworkOrg/backend#104 (issue PoliNetworkOrg/backend#100). The Member register, Receipts and Census pages stay as unconnected UI mockups with their
-> own sample data (`src/features/people/mockup-data.ts`), to be rebuilt in Phase 2 (#144, Soci and fees on Microsoft
-> 365 members) and Phase 3 (#145, the census).
->
-> Until the backend cleanup deploys, the backend still sends `member`, `isMember`, `census`, `fees`, `admin.groups`,
-> `admin.requested`, `capo.get`'s `groups` and `requests`, and in My area `feeInstructions`, `campaign`, the `none`
-> state's `request` and the contacts' and roster's `email`. The dashboard's schemas strip unknown keys, so these are
-> ignored, and nothing requires them. An account in `review` reads as `none`, and a My area `match` as `none`.
-
-## Shared types
-
-```ts
-type PersonId = string // "P-0142"
-type AccountStatus = "none" | "invite" | "linked"
-type TeamId = "it" | "hr" | "design" | "intl" | "events"
-type TeamRole = "member" | "lead"
-type Campus = "Leonardo" | "Bovisa" | "Cremona" | "Piacenza" | "Mantova" | "Lecco" | "External"
-
-type Profile = {
-  firstName: string
-  lastName: string
-  personalEmail: string | null // omitted (null) without contact rights
-  phone: string | null // omitted (null) without contact rights
-  telegramUsername: string | null
-  telegramId: string | null
-  course: string
-  year: string // "2nd year", "1st year MSc", "Graduated"
-  campus: Campus
-  otherAssociations: string[]
-  studentRepresentative: string | null
-}
-
-type AdminRole = {
-  status: "active" | "former"
-  since: string
-  endedOn: string | null
-  endReason: string | null
-  availableAsCapo: boolean
-  capoOfReference: { id: PersonId; name: string } | null
-  capoScope: string | null // set when this person is a Capo Admin, e.g. "Ingegneria Informatica"
-}
-
-type TeamMembership = {
-  team: TeamId
-  role: TeamRole
-  since: string
-  endedOn: string | null
-  endReason: string | null
-  fields: Record<string, string | string[]> // per team, see TEAM_FIELDS
-}
-
-type Account =
-  | { status: "none" }
-  | {
-      status: "invite"
-      email: string
-      sentOn: string
-      expiresOn: string
-      sentBy: string
-    }
-  | {
-      status: "linked"
-      email: string
-      via: string
-      linkedOn: string
-      how: string
-    }
-
-// Every list row: the record without notes, discrepancies and activity.
-type PersonRow = Omit<PersonRecord, "notes" | "discrepancies" | "activity">
-
-type PersonRecord = {
-  id: PersonId
-  profile: Profile
-  admin: AdminRole | null
-  teams: TeamMembership[]
-  consents: {
-    privacy: { version: string; acceptedOn: string } | null
-    photo: { status: "granted" | "denied" | "revoked"; on: string } | null
-  }
-  account: Account
-  notes: string | null // null without people:read
-  discrepancies: {
-    kind: string // the dashboard acts on "telegram-mismatch" only
-    message: string
-    suggestedTelegram?: string
-  }[]
-  activity: { actor: string; text: string; at: string }[]
-}
-```
-
-Team fields (`TEAM_FIELDS`): `it` → `github` (text), `areas` (Frontend, Backend, Bot, Infrastructure); `design` →
-`tools` (Figma, Illustrator, Photoshop, After Effects, InDesign, Premiere), `portfolio` (URL); `hr` and `events` →
-`focus` (multi); `intl` → `languages` (multi).
+The dashboard calls these procedures under `people.*` on the tRPC backend (`@polinetwork/backend`), served by the
+backend's `src/people/router.ts` (Phase 1: PoliNetworkOrg/backend#105 and #106). **`src/features/people/people.contract.ts`
+is the source of truth** for every shape and input; it is a copy of the backend's `src/people/contract.ts`, so change
+both together. In agent mode the dashboard serves the same shapes from `people.fake.server.ts` over
+`people.fixtures.server.ts`.
+
+Every procedure checks permissions server-side, and every role change is checked again by PoliNetwork Auth. Dates are
+ISO `YYYY-MM-DD` strings; timestamps ISO 8601. Actors (`assignedBy`, `sentBy`, `linkedBy`, activity `actor`) are
+account IDs, or `auth` / `system`; the dashboard shows the name of the record linked to the account when it has it.
+
+Soci, fees and receipts, the census, record matching and Telegram group tracking are not part of People (#138). Their
+pages are unconnected mockups with their own sample data (`mockup-data.ts`).
+
+## Model
+
+- **Person:** a record with a name, an optional contact email (only for invites, never to match accounts), phone and
+  Telegram username (informational only), HR notes and history.
+- **Account:** `none`, `invite` (an open invite: address, sent on, expiry, sender) or `linked` (account ID, `method`
+  `invite` / `manual` / `auth`, when and by whom). `auth` is a record People created for someone given a bound role by
+  hand in PoliNetwork Auth.
+- **Assignment:** `admin`, `capo` (with its `capoScope`) or `team` (with `team`, `teamRole` `member` / `lead` and the
+  team's fields). An admin assignment has a `capoOfReference`. Each has `since`, `endedOn` / `endReason` once ended,
+  `assignedBy`, and where it stands with Auth:
+
+  | `status`  | Meaning                                                                   | Dashboard label           |
+  | --------- | ------------------------------------------------------------------------- | ------------------------- |
+  | `pending` | The record isn't linked, so Auth knows nothing of it                      | Pending until linked      |
+  | `sent`    | Sent to Auth, not confirmed yet (`change` says whether it starts or ends) | Waiting for Auth / Ending |
+  | `applied` | Auth holds it (or, for an end, no longer does)                            | Applied                   |
+  | `refused` | Auth refused; `refusal` is its reason, shown word for word                | Refused by Auth           |
+
+  A refused start ends the assignment (it never took effect); a refused end leaves it current. While any change of a
+  linked record is `sent`, the backend refuses another role change for it.
+
+- **Teams:** `it`, `hr`, `design` (Design & Marketing), `intl`, `events`. `teams.list` reports per team whether Auth
+  binds a member and a Lead role (`assignable`); a role that isn't bound can't be assigned, and the dashboard doesn't
+  offer it. Only these kinds exist: Admin, Capo Admin, team member, team Lead.
 
 ## Procedures
 
-| Procedure                          | Kind     | Input                                                                                                   | Output                                                                                                                            | Needs                                                       |
-| ---------------------------------- | -------- | ------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------- |
-| `people.persons.list`              | query    | —                                                                                                       | `PersonRow[]`                                                                                                                     | `people:read`                                               |
-| `people.persons.get`               | query    | `{ id }`                                                                                                | `PersonRecord`                                                                                                                    | `people:read`                                               |
-| `people.persons.create`            | mutation | `Profile` fields + `{ admin: boolean }`                                                                 | `{ id }`                                                                                                                          | `people:write`                                              |
-| `people.persons.update`            | mutation | `{ id } & Partial<Profile>`                                                                             | `void`                                                                                                                            | `people:write`                                              |
-| `people.persons.setNote`           | mutation | `{ id, note: string }` (empty string clears the note)                                                   | `void`                                                                                                                            | `people:write`                                              |
-| `people.admins.end`                | mutation | `{ personId, reason }`                                                                                  | `void`                                                                                                                            | `people:write`                                              |
-| `people.admins.setCapoScope`       | mutation | `{ personId, scope: string \| null }`                                                                   | `void`                                                                                                                            | `people:appoint`                                            |
-| `people.admins.setCapoOfReference` | mutation | `{ personId, capoId: PersonId \| null }`                                                                | `void`                                                                                                                            | `people:write`                                              |
-| `people.teams.list`                | query    | —                                                                                                       | `{ id, name, lead, members: PersonRow[] }[]` (members include ended memberships)                                                  | `people:read`, or Lead of that team (only their team)       |
-| `people.teams.candidates`          | query    | `{ teamId }`                                                                                            | `{ id, name, course }[]`: people not active in the team, for Add to team                                                          | `people:read`, or Lead of that team                         |
-| `people.teams.addMember`           | mutation | `{ teamId, personId, role, since, fields }`                                                             | `void`                                                                                                                            | `people:write` or Lead (role `lead` needs `people:appoint`) |
-| `people.teams.updateFields`        | mutation | `{ teamId, personId, fields }`                                                                          | `void`                                                                                                                            | `people:write` or Lead                                      |
-| `people.teams.endMembership`       | mutation | `{ teamId, personId, lastDay, reason, note? }`                                                          | `void`                                                                                                                            | `people:write` or Lead                                      |
-| `people.linking.invites`           | query    | —                                                                                                       | `{ personId, name, email, sentOn, expiresOn, sentBy }[]`                                                                          | `people:read`                                               |
-| `people.linking.sendInvite`        | mutation | `{ personId }` (sends or resends; the old link stops working)                                           | `void`                                                                                                                            | `people:write`                                              |
-| `people.linking.revokeInvite`      | mutation | `{ personId }`                                                                                          | `void`                                                                                                                            | `people:write`                                              |
-| `people.linking.searchAccounts`    | query    | `{ personId, query }`                                                                                   | `{ id, name, email, telegram, via, linkedTo: { id, name } \| null, reason: "same-telegram" \| "same-email" \| "similar-name" }[]` | `people:write`                                              |
-| `people.linking.link`              | mutation | `{ personId, accountId, reason }` (fails `CONFLICT` when the account is linked elsewhere)               | `void`                                                                                                                            | `people:write`                                              |
-| `people.linking.unlink`            | mutation | `{ personId }`                                                                                          | `void`                                                                                                                            | `people:write`                                              |
-| `people.capo.get`                  | query    | —                                                                                                       | `{ scope, admins: PersonRow[] }` (active admins whose Capo Admin of reference is the caller)                                      | Capo Admin (scope from record)                              |
-| `people.me.get`                    | query    | —                                                                                                       | `MyArea` (below)                                                                                                                  | `people:self`                                               |
-| `people.me.roles`                  | query    | —                                                                                                       | `{ capoScope: string \| null, leads: TeamId[] }` (caller's Capo Admin scope and led teams for navigation)                         | `people:self`                                               |
-| `people.me.acceptInvite`           | mutation | `{ token }` (43-character base64url, from the invite link `/dashboard/account/me?peopleInvite=<token>`) | `void` (links the caller's account to the invited record)                                                                         | `people:self`                                               |
-
-```ts
-type MyArea =
-  | {
-      state: "linked"
-      person: PersonRecord
-      contacts: {
-        role: "capo" | "lead" | "hr"
-        name: string
-        telegram: string | null
-        team?: TeamId
-      }[]
-      roster: {
-        team: TeamId
-        members: {
-          name: string
-          role: TeamRole
-          telegram: string | null
-        }[]
-      } | null
-    }
-  | { state: "none" }
-```
-
-## Permissions
-
-IdP permissions (in `src/server/permissions.ts`): `people:self`, `people:read`, `people:write` and `people:appoint`.
-`people:members:read`, `people:members:write`, `people:fees:write` and `people:receipts:sign` are gone with Soci, fees
-and receipts (#138, deleted from the IdP in PoliNetworkOrg/auth#77). Capo Admin and Team Lead are not permissions:
-they come from the signed-in person's record (`people.me.get`), and the backend scopes `people.capo.get` and team
-writes to them.
-
-## Backend rules
-
-The dashboard checks these too, but the backend owns them (from the security review of PR 97):
-
-- **`admin:access`**: every `people.*` procedure except `people.me.*`, `people.capo.*` and the team procedures needs it on
-  top of the permission in the table. `people:self` alone reaches only My area, Capo Admin and the caller's own team. For team procedures, the general
-  `people:read`/`people:write` branch requires `admin:access`; otherwise require `people:self` and an active, confirmed
-  Lead role over the requested team. A stray general permission without `admin:access` never widens team access.
-- **`people.teams.list`**: a Lead without `people:read` gets contacts (phone, personal email) only for the team's
-  current members; former members come back without them.
-- **`people.teams.endMembership`**: ending a lead's membership needs `people:appoint`, like appointing one. A team has at most one Lead:
-  `people.teams.addMember` with `role: "lead"` fails `CONFLICT` while another Lead's appointment is open.
-- **`people.admins.end`**: ending a Capo Admin's admin role also ends the scope, so it needs `people:appoint` too.
-- **`people.me.acceptInvite`**: the token alone identifies the invited record (store it hashed); it fails while the
-  invite is revoked, expired or already used, or when the caller already has a linked record.
-- **Input limits**: the input schemas in `people.contract.ts` bound every string, array and record (team fields: at most
-  10 keys of 40 characters, values of 200, lists of 20). Telegram usernames are empty or 5–32 letters, digits and
-  underscores, with an optional leading `@`.
-
-Security review verification (PR #97): scope checks, the Capo Admin area and ending Lead roles are exercised in
-`tests/people-access.test.mjs`; bounded input and parsing of the current backend's legacy fields in
-`tests/people-input.test.mjs`. General People middleware starts from `adminMiddleware`; team exceptions follow the
-rule above.
-
-Input limits also cover opaque IDs (128 chars), emails (254) and real ISO calendar dates
-(invalid days are rejected). Reject oversize requests before parsing.
+| Procedure                             | Kind             | Input                                                                  | Needs                                                          |
+| ------------------------------------- | ---------------- | ---------------------------------------------------------------------- | -------------------------------------------------------------- |
+| `persons.list` / `persons.get`        | query            | — / `{ id }`                                                           | `admin:access` + `people:read`                                 |
+| `persons.create`                      | mutation         | name, `contactEmail`, `phone`, `telegramUsername` (empty when unknown) | `people:write`                                                 |
+| `persons.update` / `setNote`          | mutation         | `{ id, … }` / `{ id, note }`                                           | `people:write`                                                 |
+| `admins.list`                         | query            | —                                                                      | `people:read`                                                  |
+| `admins.assign`                       | mutation         | `{ personId, since, capoId }`                                          | `people:write`                                                 |
+| `admins.end`                          | mutation         | `{ personId, reason }` (Capo Admin role ended first)                   | `people:write`                                                 |
+| `admins.setCapoOfReference`           | mutation         | `{ personId, capoId }`                                                 | `people:write`                                                 |
+| `capos.list`                          | query            | —                                                                      | `people:read`                                                  |
+| `capos.appoint`                       | mutation         | `{ personId, since, scope }` (a current admin)                         | `people:appoint`                                               |
+| `capos.setScope` / `capos.end`        | mutation         | `{ personId, scope }` / `{ personId, reason }`                         | `people:appoint`                                               |
+| `teams.list` / `teams.candidates`     | query            | — / `{ teamId }`                                                       | `people:read`, or a Lead for their own team                    |
+| `teams.addMember`                     | mutation         | `{ teamId, personId, role, since, fields }`                            | `people:write` or the team's Lead; `people:appoint` for a Lead |
+| `teams.updateFields`                  | mutation         | `{ teamId, personId, fields }`                                         | `people:write` or the team's Lead                              |
+| `teams.endMembership`                 | mutation         | `{ teamId, personId, reason }`                                         | as `addMember`, by the membership's role                       |
+| `linking.invites` / `recent`          | query            | —                                                                      | `people:read`                                                  |
+| `linking.sendInvite` / `revokeInvite` | mutation         | `{ personId }`                                                         | `people:write`, or Lead of one of the person's teams           |
+| `linking.searchAccounts`              | query            | `{ query }`                                                            | `people:link`                                                  |
+| `linking.link`                        | mutation         | `{ personId, accountId, reason }`                                      | `people:link`                                                  |
+| `linking.unlink`                      | mutation         | `{ personId, reason }`                                                 | `people:link`                                                  |
+| `capo.get`                            | query            | —                                                                      | `people:self`, as a current Capo Admin                         |
+| `me.roles` / `me.get`                 | query            | —                                                                      | `people:self`                                                  |
+| `me.invite` / `me.acceptInvite`       | query / mutation | `{ token }`                                                            | any signed-in account                                          |
+
+Nobody gives themselves a role (giving one up is always allowed), and nobody hands out a role granting permissions they
+don't hold; the backend applies the same rules as Auth (`src/people/rules.ts`) to pending assignments, and Auth checks
+linked ones again. A Capo Admin of reference must be in effect: not an appointment still waiting for Auth. Start dates
+can't be later than today in Europe/Rome.
+
+**Linking** sends every pending assignment to Auth: by hand, acting as whoever links; by invite, acting as each
+assignment's `assignedBy`. **Unlinking** asks Auth to take the record's roles back first; once it confirms, the account
+is detached and the assignments wait as `pending` again.
+
+## Dashboard composition
+
+Add person creates the record, then calls `admins.assign`, `capos.appoint` and `teams.addMember` for the roles it starts
+with (`createPerson` in `people-write.functions.ts`). A refused role doesn't undo the record: the page reports which
+roles weren't given, in the backend's words.
diff --git a/docs/people/permissions.md b/docs/people/permissions.md
index 111b00e..ce50d0a 100644
--- a/docs/people/permissions.md
+++ b/docs/people/permissions.md
@@ -2,21 +2,24 @@
 
 Permissions are additive and never imply one another. Administrative pages/actions below also need `admin:access`.
 Only My area, an active Capo Admin's scope and a Team Lead's own teams work with `people:self` alone. Record roles
-count only after account linking is confirmed. “Team member” means a volunteer in a team. `people:members:read`,
+count only once PoliNetwork Auth holds them (the record is linked and the role applied). “Team member” means a volunteer in a team. `people:members:read`,
 `people:members:write`, `people:fees:write` and `people:receipts:sign` were removed in #138.
 
 | Viewer / extra permissions                     | Pages                                                      | Actions                                                                                                                                |
 | ---------------------------------------------- | ---------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
-| Volunteer: `people:self`, P-0115               | My area, Sign-in & security                                | Read own record and roles                                                                                                              |
-| Team Lead: `people:self`, P-0034               | Above + own team(s) under People                           | Add team members, edit team fields, end ordinary team memberships; never appoint or end a Lead without `people:appoint` + admin access |
-| Capo Admin: `people:self`, P-0098              | My area + Telegram › Capo Admin                            | Contact the admins who have them as Capo Admin of reference                                                                            |
+| Volunteer: `people:self`, P-0021               | My area, Sign-in & security                                | Read own record and roles                                                                                                              |
+| Team Lead: `people:self`, P-0030               | Above + own team(s) under People                           | Add team members, edit team fields, end ordinary team memberships; never appoint or end a Lead without `people:appoint` + admin access |
+| Capo Admin: `people:self`, P-0003              | My area + Telegram › Capo Admin                            | Read-only list of the admins who have them as Capo Admin of reference                                                                  |
 | `people:read`                                  | People overview, person records, Admins, Teams, Linking    | Read contacts and notes; no editing, linking or appointments                                                                           |
+| `people:link`                                  | Link account and Unlink on records and Overview            | Search the IdP's accounts, link one by hand, unlink (Auth revokes the roles first)                                                     |
 | `people:read` (mockups)                        | Member register, Receipts, Census; the fee card in My area | None: unconnected mockups with sample data (#138), to be rebuilt in Phase 2 (#144) and Phase 3 (#145)                                  |
 | Master Admin: all explicit permissions, P-0007 | All permitted sections                                     | All People mutations                                                                                                                   |
 
-`people:write` enables profile, admin-role, team and linking mutations on readable pages;
-`people:appoint` enables Capo/Lead appointments and ending those roles. Without their read prerequisites, write
-permissions alone do not open a page. Buttons and row links follow these same rules; one available action is direct.
+`people:write` enables record, admin-role, team and invite mutations on readable pages;
+`people:appoint` enables Capo/Lead appointments and ending those roles; `people:link` enables linking by hand and
+unlinking. Nobody gives themselves a role, though anyone may give one up: P-0007 (agent mode's default `AGENT_PERSON`)
+can't add roles to their own record. Without their read prerequisites, write permissions alone do not open a page.
+Buttons and row links follow these same rules; one available action is direct.
 
 ## Verification
 
diff --git a/docs/people/plan.md b/docs/people/plan.md
index 55da677..3771b90 100644
--- a/docs/people/plan.md
+++ b/docs/people/plan.md
@@ -208,3 +208,15 @@ Newest last. One line per commit or session: date, what was done, what is next.
   `people:members:read`, `people:members:write`, `people:fees:write` and `people:receipts:sign`. The schemas strip the
   fields the current backend still sends until its own cleanup deploys.
   The backend counterpart is PoliNetworkOrg/backend#104, which deploys after this.
+
+- 2026-10-31: Phase 1 pages (#139), on the API from PoliNetworkOrg/backend#105 and #106. The contract is a copy of
+  the backend's: records with a name and contacts, and assignments (Admin, Capo Admin, team member or Lead) whose
+  status says where each stands with PoliNetwork Auth (pending until linked, waiting for Auth, applied, refused with
+  Auth's reason). Overview filters by role, team, account and status; the person page lists each role with its status,
+  the past roles and the history, with actors named from linked records. Add person needs only a name, and can start
+  with roles. Admins shows admins with their Capo Admin of reference and the Capo Admins with their scope; the Capo
+  Admin area is read-only. Teams honour which roles Auth binds. New permission `people:link` for linking by hand and
+  unlinking (with a reason; Auth revokes the roles first). Course, year and campus are gone from records, so #132's
+  "—" handling has nothing left to apply to; the Design team is Design & Marketing. Agent-mode fixtures cover linked,
+  invited and unlinked records and every assignment status; fake Auth confirms changes after a few seconds and refuses
+  every change for P-0012.
diff --git a/src/features/people/account-action-dialog.tsx b/src/features/people/account-action-dialog.tsx
index 6684181..b51908e 100644
--- a/src/features/people/account-action-dialog.tsx
+++ b/src/features/people/account-action-dialog.tsx
@@ -1,20 +1,20 @@
 import { useServerFn } from "@tanstack/react-start"
-import { Mail, RefreshCw, Unlink, X } from "lucide-react"
+import { Mail, RefreshCw, X } from "lucide-react"
 
 import { ConfirmDialog } from "@/components/primitives"
 
 import { useRefreshAfter } from "./people-hooks"
-import { revokePersonInvite, sendPersonInvite, unlinkPersonAccount } from "./people-write.functions"
+import { revokePersonInvite, sendPersonInvite } from "./people-invites.functions"
 
 export type AccountAction = {
-  kind: "invite" | "resend" | "revoke" | "unlink"
+  kind: "invite" | "resend" | "revoke"
   personId: string
   name: string
-  /** The invite address, or the linked sign-in for `unlink`. */
+  /** The invite address: the record's contact email. */
   email: string
 }
 
-/** Send, resend or revoke an invite, or unlink an account. Keep `action` after closing so the text survives the exit. */
+/** Send, resend or revoke an invite. Keep `action` after closing so the text survives the exit. */
 export function AccountActionDialog({
   action,
   open,
@@ -26,7 +26,6 @@ export function AccountActionDialog({
 }) {
   const send = useServerFn(sendPersonInvite)
   const revoke = useServerFn(revokePersonInvite)
-  const unlink = useServerFn(unlinkPersonAccount)
   const refresh = useRefreshAfter()
   if (!action) return null
   const data = { personId: action.personId }
@@ -40,7 +39,7 @@ export function AccountActionDialog({
         tone="primary"
         icon={resend ? RefreshCw : Mail}
         title={resend ? "Resend invite?" : "Send invite?"}
-        description={`${action.name} gets an email at ${action.email} with a link to sign in and link their account. The link expires in 14 days${resend ? " and the previous one stops working." : "."}`}
+        description={`${action.name} gets an email at ${action.email} with a link that works once. They can sign in with any account, not only this address. It expires in 14 days${resend ? ", and the previous link stops working." : "."}`}
         confirmLabel={resend ? "Resend invite" : "Send invite"}
         onConfirm={async () => {
           await send({ data })
@@ -49,33 +48,17 @@ export function AccountActionDialog({
       />
     )
   }
-  if (action.kind === "revoke") {
-    return (
-      <ConfirmDialog
-        open={open}
-        onOpenChange={onOpenChange}
-        icon={X}
-        title="Revoke invite?"
-        description={`The link sent to ${action.email} stops working. ${action.name} stays on the list as Not linked.`}
-        confirmLabel="Revoke invite"
-        onConfirm={async () => {
-          await revoke({ data })
-          await refresh("Invite revoked.")
-        }}
-      />
-    )
-  }
   return (
     <ConfirmDialog
       open={open}
       onOpenChange={onOpenChange}
-      icon={Unlink}
-      title="Unlink account?"
-      description={`${action.email} can no longer see ${action.name}'s record. The record and its history stay.`}
-      confirmLabel="Unlink account"
+      icon={X}
+      title="Revoke invite?"
+      description={`The link sent to ${action.email} stops working. ${action.name} stays on the list as Not linked.`}
+      confirmLabel="Revoke invite"
       onConfirm={async () => {
-        await unlink({ data })
-        await refresh("Account unlinked.")
+        await revoke({ data })
+        await refresh("Invite revoked.")
       }}
     />
   )
diff --git a/src/features/people/admin-dialogs.tsx b/src/features/people/admin-dialogs.tsx
index 0942703..3d1390d 100644
--- a/src/features/people/admin-dialogs.tsx
+++ b/src/features/people/admin-dialogs.tsx
@@ -1,9 +1,8 @@
 import { useServerFn } from "@tanstack/react-start"
-import { Crown } from "lucide-react"
 import { useMemo, useState } from "react"
 
 import {
-  ConfirmDialog,
+  DateField,
   fieldControl,
   fieldHintId,
   FormDialog,
@@ -11,50 +10,93 @@ import {
   SelectField,
   Spinner,
 } from "@/components/primitives"
+import { Input } from "@/components/ui/input"
 import { Textarea } from "@/components/ui/textarea"
 import { cn } from "@/lib/utils"
 
-import { setCapoScope } from "./people-appoint.functions"
-import { personName } from "./people-format"
-import { errorMessage, useLoaded, useRefreshAfter } from "./people-hooks"
-import { endAdminRole, setCapoOfReference } from "./people-write.functions"
-import { COURSES, type PersonRow } from "./people.contract"
-import { getPeople } from "./people.functions"
+import { appointCapo, endCapo, setCapoScope } from "./people-appoint.functions"
+import { personName, todayIso } from "./people-format"
+import { errorMessage, useLoaded, useRefreshAfter, useReloadAfterFailure } from "./people-hooks"
+import { type PersonOption, PersonPicker } from "./people-ui"
+import { assignAdmin, endAdminRole, setCapoOfReference } from "./people-write.functions"
+import type { CapoSummary } from "./people.contract"
+import { getAdminsAndCapos } from "./people.functions"
 
 const END_REASONS = ["Graduated", "No longer has time", "Left the association", "Removed by HR", "Other"] as const
 type EndReason = (typeof END_REASONS)[number]
 
 export type AdminTarget = { personId: string; name: string }
 
-/** Ends an admin role with a reason; the bot removes their admin rights. */
-export function EndAdminDialog({
+const NONE = "none"
+
+/**
+ * "Giulia Rossi · Ingegneria Informatica", for choosing a Capo Admin. Not one whose appointment Auth hasn't confirmed
+ * yet: the backend only accepts a Capo Admin in effect.
+ */
+function capoOptions(capos: readonly CapoSummary[], exclude?: string) {
+  return capos
+    .filter((capo) => capo.person.id !== exclude && !(capo.capo.change === "start" && capo.capo.status === "sent"))
+    .map((capo) => ({
+      value: capo.person.id,
+      label: `${personName(capo.person)}${capo.capo.capoScope ? ` · ${capo.capo.capoScope}` : ""}`,
+    }))
+    .toSorted((a, b) => a.label.localeCompare(b.label))
+}
+
+/** The Capo Admins, from the page when it has them, otherwise loaded while the dialog is open. */
+function useCapos(open: boolean, capos: readonly CapoSummary[] | undefined) {
+  const load = useServerFn(getAdminsAndCapos)
+  const { data, failed } = useLoaded(
+    useMemo(() => (open && !capos ? async () => (await load()).capos : null), [open, capos, load])
+  )
+  return { capos: capos ?? data, failed }
+}
+
+/** A role change's outcome: pending until the record is linked, otherwise sent to PoliNetwork Auth. */
+export function changeOutcome(linked: boolean, done: string) {
+  return linked ? `${done} PoliNetwork Auth applies it shortly.` : `${done} It waits until the record is linked.`
+}
+
+/**
+ * Makes a person an admin. `person` fixes who (their record); otherwise the dialog offers `candidates`. For a linked
+ * record Auth applies it, and may refuse; for an unlinked one it waits as pending.
+ */
+export function AssignAdminDialog({
   open,
   onOpenChange,
-  target,
+  person: fixedPerson,
+  candidates = [],
+  capos: givenCapos,
 }: {
   open: boolean
   onOpenChange: (open: boolean) => void
-  target: AdminTarget
+  person?: PersonOption & { linked: boolean }
+  candidates?: readonly (PersonOption & { linked: boolean })[]
+  capos?: readonly CapoSummary[]
 }) {
-  const end = useServerFn(endAdminRole)
+  const assign = useServerFn(assignAdmin)
   const refresh = useRefreshAfter()
-  const [reason, setReason] = useState<EndReason | null>(null)
-  const [details, setDetails] = useState("")
+  const reload = useReloadAfterFailure()
+  const [person, setPerson] = useState<PersonOption | null>(fixedPerson ?? null)
+  const [since, setSince] = useState(todayIso())
+  const [capo, setCapo] = useState(NONE)
   const [submitted, setSubmitted] = useState(false)
-  const reasonError = submitted && !reason ? "Choose a reason." : undefined
-  const detailsError = submitted && reason === "Other" && !details.trim() ? "Describe the reason." : undefined
+  const { capos, failed } = useCapos(open, givenCapos)
+  const personError = submitted && !person ? "Choose a person." : undefined
+  const sinceError = submitted && !since ? "Choose the start date." : undefined
 
   async function submit() {
     setSubmitted(true)
-    if (!reason || (reason === "Other" && !details.trim())) return
-    const text = reason === "Other" ? details.trim() : details.trim() ? `${reason}: ${details.trim()}` : reason
+    if (!person || !since) return
     try {
-      await end({ data: { personId: target.personId, reason: text } })
+      await assign({ data: { personId: person.id, since, capoId: capo === NONE ? null : capo } })
     } catch (caught) {
       console.error(caught)
-      throw new Error(errorMessage(caught, "Couldn't end the admin role."), { cause: caught })
+      reload()
+      throw new Error(errorMessage(caught, "Couldn't make them an admin."), { cause: caught })
     }
-    await refresh("Admin role ended.")
+    const linked = fixedPerson?.linked ?? candidates.find((candidate) => candidate.id === person.id)?.linked ?? false
+    await refresh(changeOutcome(linked, `${person.name} is an admin.`))
     onOpenChange(false)
   }
 
@@ -62,79 +104,237 @@ export function EndAdminDialog({
     <FormDialog
       open={open}
       onOpenChange={onOpenChange}
-      title="End admin role?"
-      description={`${target.name} stops being an admin. The bot removes their admin rights; the record keeps the history.`}
-      noun="change"
-      dirty={reason !== null || details.trim() !== ""}
-      submitLabel="End admin role"
-      tone="danger"
+      title="Make admin"
+      description={fixedPerson ? fixedPerson.name : "Admins administer Telegram groups."}
+      noun="admin role"
+      dirty={(!fixedPerson && person !== null) || since !== todayIso() || capo !== NONE}
+      submitLabel="Make admin"
       onSubmit={submit}
     >
       <div className="flex flex-col gap-4">
-        <FormField label="Reason" htmlFor="end-admin-reason" error={reasonError}>
-          <SelectField<EndReason>
-            id="end-admin-reason"
-            value={reason}
-            options={END_REASONS.map((value) => ({ value, label: value }))}
-            onChange={setReason}
-            placeholder="Choose a reason"
-            invalid={!!reasonError}
+        {fixedPerson ? null : (
+          <FormField
+            label="Person"
+            htmlFor="assign-admin-person"
+            hint="Not in the list? Add the person from Overview first."
+            error={personError}
+          >
+            <PersonPicker
+              id="assign-admin-person"
+              people={candidates}
+              value={person}
+              onChange={setPerson}
+              invalid={!!personError}
+            />
+          </FormField>
+        )}
+        <FormField label="Since" htmlFor="assign-admin-since" error={sinceError}>
+          <DateField
+            id="assign-admin-since"
+            value={since}
+            onChange={setSince}
+            invalid={!!sinceError}
+            describedBy={sinceError ? fieldHintId("assign-admin-since") : undefined}
           />
         </FormField>
         <FormField
-          label="Details"
-          htmlFor="end-admin-details"
-          optional={reason !== "Other"}
-          hint="Saved in the record's activity."
-          error={detailsError}
+          label="Capo Admin of reference"
+          htmlFor="assign-admin-capo"
+          optional
+          error={failed ? "Couldn't load the Capo Admins. Close and try again." : undefined}
         >
-          <Textarea
-            id="end-admin-details"
-            value={details}
-            onChange={(event) => setDetails(event.target.value)}
-            maxLength={400}
-            aria-invalid={detailsError ? true : undefined}
-            aria-describedby={fieldHintId("end-admin-details")}
-            className={cn(fieldControl, "min-h-20")}
-          />
+          {capos === null && !failed ? (
+            <Spinner className="size-4" />
+          ) : (
+            <SelectField
+              id="assign-admin-capo"
+              value={capo}
+              options={[{ value: NONE, label: "No Capo Admin" }, ...capoOptions(capos ?? [], person?.id)]}
+              onChange={setCapo}
+            />
+          )}
         </FormField>
       </div>
     </FormDialog>
   )
 }
 
-type CapoOption = { id: string; label: string }
+/** The reason an admin or Capo Admin role ends: a preset, or free text for Other; saved in the record. */
+function EndReasonFields({
+  id,
+  submitted,
+  reason,
+  details,
+  onReason,
+  onDetails,
+}: {
+  id: string
+  submitted: boolean
+  reason: EndReason | null
+  details: string
+  onReason: (reason: EndReason) => void
+  onDetails: (details: string) => void
+}) {
+  const reasonError = submitted && !reason ? "Choose a reason." : undefined
+  const detailsError = submitted && reason === "Other" && !details.trim() ? "Describe the reason." : undefined
+  return (
+    <div className="flex flex-col gap-4">
+      <FormField label="Reason" htmlFor={`${id}-reason`} error={reasonError}>
+        <SelectField<EndReason>
+          id={`${id}-reason`}
+          value={reason}
+          options={END_REASONS.map((value) => ({ value, label: value }))}
+          onChange={onReason}
+          placeholder="Choose a reason"
+          invalid={!!reasonError}
+        />
+      </FormField>
+      <FormField
+        label="Details"
+        htmlFor={`${id}-details`}
+        optional={reason !== "Other"}
+        hint="Saved in the record's activity."
+        error={detailsError}
+      >
+        <Textarea
+          id={`${id}-details`}
+          value={details}
+          onChange={(event) => onDetails(event.target.value)}
+          maxLength={400}
+          aria-invalid={detailsError ? true : undefined}
+          aria-describedby={fieldHintId(`${id}-details`)}
+          className={cn(fieldControl, "min-h-20")}
+        />
+      </FormField>
+    </div>
+  )
+}
 
-function capoOptions(people: readonly PersonRow[]): CapoOption[] {
-  return people
-    .filter((person) => person.admin?.status === "active" && person.admin.capoScope)
-    .map((person) => ({ id: person.id, label: `${personName(person)} · ${person.admin?.capoScope ?? ""}` }))
-    .toSorted((a, b) => a.label.localeCompare(b.label))
+function reasonText(reason: EndReason, details: string) {
+  const extra = details.trim()
+  if (reason === "Other") return extra
+  return extra ? `${reason}: ${extra}` : reason
 }
 
-const NONE = "none"
+/** Ends an admin or Capo Admin role with a reason. A linked record's role is taken back in Auth. */
+function EndRoleDialog({
+  open,
+  onOpenChange,
+  target,
+  linked,
+  role,
+  description,
+  end,
+}: {
+  open: boolean
+  onOpenChange: (open: boolean) => void
+  target: AdminTarget
+  linked: boolean
+  role: "admin" | "Capo Admin"
+  description: string
+  end: (data: { personId: string; reason: string }) => Promise<void>
+}) {
+  const refresh = useRefreshAfter()
+  const reload = useReloadAfterFailure()
+  const [reason, setReason] = useState<EndReason | null>(null)
+  const [details, setDetails] = useState("")
+  const [submitted, setSubmitted] = useState(false)
+
+  async function submit() {
+    setSubmitted(true)
+    if (!reason || (reason === "Other" && !details.trim())) return
+    try {
+      await end({ personId: target.personId, reason: reasonText(reason, details) })
+    } catch (caught) {
+      console.error(caught)
+      reload()
+      throw new Error(errorMessage(caught, `Couldn't end the ${role} role.`), { cause: caught })
+    }
+    await refresh(
+      linked
+        ? `${target.name}'s ${role} role is ending. PoliNetwork Auth takes it back shortly.`
+        : `${target.name}'s ${role} role ended.`
+    )
+    onOpenChange(false)
+  }
+
+  return (
+    <FormDialog
+      open={open}
+      onOpenChange={onOpenChange}
+      title={`End ${role} role?`}
+      description={description}
+      noun="change"
+      dirty={reason !== null || details.trim() !== ""}
+      submitLabel={`End ${role} role`}
+      tone="danger"
+      onSubmit={submit}
+    >
+      <EndReasonFields
+        id="end-role"
+        submitted={submitted}
+        reason={reason}
+        details={details}
+        onReason={setReason}
+        onDetails={setDetails}
+      />
+    </FormDialog>
+  )
+}
+
+export function EndAdminDialog(props: {
+  open: boolean
+  onOpenChange: (open: boolean) => void
+  target: AdminTarget
+  linked: boolean
+}) {
+  const end = useServerFn(endAdminRole)
+  return (
+    <EndRoleDialog
+      {...props}
+      role="admin"
+      description={`${props.target.name} stops being an admin. ${props.linked ? "PoliNetwork Auth takes the role back; " : ""}the record keeps the history.`}
+      end={(data) => end({ data })}
+    />
+  )
+}
+
+export function EndCapoDialog(props: {
+  open: boolean
+  onOpenChange: (open: boolean) => void
+  target: AdminTarget
+  linked: boolean
+  scope: string
+}) {
+  const end = useServerFn(endCapo)
+  return (
+    <EndRoleDialog
+      {...props}
+      role="Capo Admin"
+      description={`${props.target.name} stops being Capo Admin of ${props.scope} and stays an admin. The admins who answered to them have no Capo Admin until you set one.`}
+      end={(data) => end({ data })}
+    />
+  )
+}
 
-/** Which Capo Admin an admin answers to. Loads the Capo Admins itself when the page has no people list. */
+/** Which Capo Admin an admin answers to: People's own data, nothing changes in Auth. */
 export function CapoOfReferenceDialog({
   open,
   onOpenChange,
   target,
   current,
-  people,
+  capos: givenCapos,
 }: {
   open: boolean
   onOpenChange: (open: boolean) => void
   target: AdminTarget
   current: string | null
-  people?: readonly PersonRow[]
+  capos?: readonly CapoSummary[]
 }) {
   const save = useServerFn(setCapoOfReference)
-  const load = useServerFn(getPeople)
   const refresh = useRefreshAfter()
   const [value, setValue] = useState(current ?? NONE)
-  // Pages that already hold every person pass them; the record page loads them.
-  const { data: rows, failed: loadError } = useLoaded(useMemo(() => (people ? null : () => load()), [people, load]))
-  const loaded = people ? capoOptions(people) : rows ? capoOptions(rows) : null
+  const { capos, failed } = useCapos(open, givenCapos)
 
   async function submit() {
     if (value === (current ?? NONE)) {
@@ -151,70 +351,99 @@ export function CapoOfReferenceDialog({
     onOpenChange(false)
   }
 
-  const options = [
-    { value: NONE, label: "No Capo Admin" },
-    ...(loaded ?? []).map((option) => ({ value: option.id, label: option.label })),
-  ]
-
   return (
     <FormDialog
       open={open}
       onOpenChange={onOpenChange}
       title="Capo Admin of reference"
-      description={`The Capo Admin ${target.name} answers to. They see ${target.name} in Telegram › Capo Admin and in My area.`}
+      description={`The Capo Admin ${target.name} answers to. They see ${target.name} in Telegram › Capo Admin.`}
       noun="change"
       dirty={value !== (current ?? NONE)}
       submitLabel="Save"
-      canSubmit={loaded !== null}
+      canSubmit={capos !== null}
       onSubmit={submit}
     >
       <FormField
         label="Capo Admin"
         htmlFor="capo-of-reference"
-        error={loadError ? "Couldn't load the Capo Admins. Close and try again." : undefined}
+        error={failed ? "Couldn't load the Capo Admins. Close and try again." : undefined}
       >
-        {loaded === null && !loadError ? (
+        {capos === null && !failed ? (
           <Spinner className="size-4" />
         ) : (
-          <SelectField id="capo-of-reference" value={value} options={options} onChange={setValue} />
+          <SelectField
+            id="capo-of-reference"
+            value={value}
+            options={[{ value: NONE, label: "No Capo Admin" }, ...capoOptions(capos ?? [], target.personId)]}
+            onChange={setValue}
+          />
         )}
       </FormField>
     </FormDialog>
   )
 }
 
-/** Appoints a Capo Admin of a course, or changes their course. Direttivo only. */
-export function CapoScopeDialog({
+/** What a Capo Admin coordinates, e.g. a course: free text, at most 120 characters. */
+function ScopeField({ value, onChange, error }: { value: string; onChange: (value: string) => void; error?: string }) {
+  return (
+    <FormField
+      label="Capo Admin of"
+      htmlFor="capo-scope"
+      hint="A course or area, e.g. Ingegneria Informatica."
+      error={error}
+    >
+      <Input
+        id="capo-scope"
+        value={value}
+        onChange={(event) => onChange(event.target.value)}
+        maxLength={120}
+        autoComplete="off"
+        aria-invalid={error ? true : undefined}
+        aria-describedby={fieldHintId("capo-scope")}
+        className={fieldControl}
+      />
+    </FormField>
+  )
+}
+
+/**
+ * Appoints a current admin Capo Admin. `person` fixes who (their record); otherwise the dialog offers `candidates`,
+ * the admins who aren't Capo Admins yet.
+ */
+export function AppointCapoDialog({
   open,
   onOpenChange,
-  target,
-  scope,
+  person: fixedPerson,
+  candidates = [],
 }: {
   open: boolean
   onOpenChange: (open: boolean) => void
-  target: AdminTarget
-  scope: string | null
+  person?: PersonOption & { linked: boolean }
+  candidates?: readonly (PersonOption & { linked: boolean })[]
 }) {
-  const save = useServerFn(setCapoScope)
+  const appoint = useServerFn(appointCapo)
   const refresh = useRefreshAfter()
-  const [value, setValue] = useState<string | null>(scope)
+  const reload = useReloadAfterFailure()
+  const [person, setPerson] = useState<PersonOption | null>(fixedPerson ?? null)
+  const [since, setSince] = useState(todayIso())
+  const [scope, setScope] = useState("")
   const [submitted, setSubmitted] = useState(false)
-  const error = submitted && !value ? "Choose a course." : undefined
+  const personError = submitted && !person ? "Choose an admin." : undefined
+  const scopeError = submitted && !scope.trim() ? "Enter what they coordinate." : undefined
+  const sinceError = submitted && !since ? "Choose the start date." : undefined
 
   async function submit() {
     setSubmitted(true)
-    if (!value) return
-    if (value === scope) {
-      onOpenChange(false)
-      return
-    }
+    if (!person || !scope.trim() || !since) return
     try {
-      await save({ data: { personId: target.personId, scope: value } })
+      await appoint({ data: { personId: person.id, since, scope: scope.trim() } })
     } catch (caught) {
       console.error(caught)
-      throw new Error(errorMessage(caught, "Couldn't save the Capo Admin role."), { cause: caught })
+      reload()
+      throw new Error(errorMessage(caught, "Couldn't appoint the Capo Admin."), { cause: caught })
     }
-    await refresh(scope ? "Capo Admin scope changed." : `${target.name} appointed Capo Admin.`)
+    const linked = fixedPerson?.linked ?? candidates.find((candidate) => candidate.id === person.id)?.linked ?? false
+    await refresh(changeOutcome(linked, `${person.name} appointed Capo Admin.`))
     onOpenChange(false)
   }
 
@@ -222,33 +451,51 @@ export function CapoScopeDialog({
     <FormDialog
       open={open}
       onOpenChange={onOpenChange}
-      title={scope ? "Change Capo Admin scope" : "Appoint as Capo Admin"}
-      description={`${target.name} coordinates the admins of the course's groups and sees them in Telegram › Capo Admin.`}
+      title="Appoint Capo Admin"
+      description={`${fixedPerson ? fixedPerson.name : "An admin"} coordinates the admins who have them as Capo Admin of reference, and sees them in Telegram › Capo Admin.`}
       noun="appointment"
-      dirty={value !== scope}
-      submitLabel={scope ? "Change scope" : "Appoint Capo Admin"}
+      dirty={(!fixedPerson && person !== null) || scope.trim() !== "" || since !== todayIso()}
+      submitLabel="Appoint Capo Admin"
       onSubmit={submit}
     >
-      <FormField label="Course" htmlFor="capo-scope" error={error}>
-        <SelectField
-          id="capo-scope"
-          value={value}
-          options={COURSES.map((course) => ({ value: course, label: course }))}
-          onChange={setValue}
-          placeholder="Choose a course"
-          invalid={!!error}
-        />
-      </FormField>
+      <div className="flex flex-col gap-4">
+        {fixedPerson ? null : (
+          <FormField
+            label="Admin"
+            htmlFor="appoint-capo-person"
+            hint="Only current admins can be Capo Admins."
+            error={personError}
+          >
+            <PersonPicker
+              id="appoint-capo-person"
+              people={candidates}
+              value={person}
+              onChange={setPerson}
+              invalid={!!personError}
+            />
+          </FormField>
+        )}
+        <ScopeField value={scope} onChange={setScope} error={scopeError} />
+        <FormField label="Since" htmlFor="appoint-capo-since" error={sinceError}>
+          <DateField
+            id="appoint-capo-since"
+            value={since}
+            onChange={setSince}
+            invalid={!!sinceError}
+            describedBy={sinceError ? fieldHintId("appoint-capo-since") : undefined}
+          />
+        </FormField>
+      </div>
     </FormDialog>
   )
 }
 
-/** Ends the Capo Admin role; they stay an admin. */
-export function EndCapoDialog({
+/** Changes what a Capo Admin coordinates: People's own data, nothing changes in Auth. */
+export function CapoScopeDialog({
   open,
   onOpenChange,
   target,
-  scope,
+  scope: currentScope,
 }: {
   open: boolean
   onOpenChange: (open: boolean) => void
@@ -257,19 +504,39 @@ export function EndCapoDialog({
 }) {
   const save = useServerFn(setCapoScope)
   const refresh = useRefreshAfter()
+  const [scope, setScope] = useState(currentScope)
+  const [submitted, setSubmitted] = useState(false)
+  const error = submitted && !scope.trim() ? "Enter what they coordinate." : undefined
+
+  async function submit() {
+    setSubmitted(true)
+    if (!scope.trim()) return
+    if (scope.trim() === currentScope) {
+      onOpenChange(false)
+      return
+    }
+    try {
+      await save({ data: { personId: target.personId, scope: scope.trim() } })
+    } catch (caught) {
+      console.error(caught)
+      throw new Error(errorMessage(caught, "Couldn't change the scope."), { cause: caught })
+    }
+    await refresh("Capo Admin scope changed.")
+    onOpenChange(false)
+  }
+
   return (
-    <ConfirmDialog
+    <FormDialog
       open={open}
       onOpenChange={onOpenChange}
-      tone="danger"
-      icon={Crown}
-      title="End Capo Admin role?"
-      description={`${target.name} stops being Capo Admin of ${scope}. They stay an admin of their groups; the admins who answered to them have no Capo Admin until you set one.`}
-      confirmLabel="End Capo Admin role"
-      onConfirm={async () => {
-        await save({ data: { personId: target.personId, scope: null } })
-        await refresh("Capo Admin role ended.")
-      }}
-    />
+      title="Change Capo Admin scope"
+      description={target.name}
+      noun="change"
+      dirty={scope.trim() !== currentScope}
+      submitLabel="Change scope"
+      onSubmit={submit}
+    >
+      <ScopeField value={scope} onChange={setScope} error={error} />
+    </FormDialog>
   )
 }
diff --git a/src/features/people/admins-page.tsx b/src/features/people/admins-page.tsx
index 1e3f4b7..f83b202 100644
--- a/src/features/people/admins-page.tsx
+++ b/src/features/people/admins-page.tsx
@@ -1,4 +1,4 @@
-import { Crown, Send, ShieldUser, UserMinus, UserRoundCog } from "lucide-react"
+import { Crown, Pencil, Send, ShieldPlus, ShieldUser, UserMinus, UserRoundCog } from "lucide-react"
 import { useDeferredValue, useState } from "react"
 
 import {
@@ -14,200 +14,226 @@ import {
   RowActions,
   SegmentedControl,
   type TableSort,
-  ToggleFilter,
   Unset,
-  useOpenGeneration,
 } from "@/components/primitives"
 import { Count, PageBar, PageContent, Toolbar, useCan } from "@/components/shell"
 import { Button } from "@/components/ui/button"
 import { pluralize } from "@/lib/format"
 
 import {
-  type AdminTarget,
+  AppointCapoDialog,
+  AssignAdminDialog,
   CapoOfReferenceDialog,
   CapoScopeDialog,
   EndAdminDialog,
   EndCapoDialog,
 } from "./admin-dialogs"
-import { formatDay, personName, telegramUrl, yearOf } from "./people-format"
-import { ActionMenu, PersonCell, TruncatedChip } from "./people-ui"
-import { type AdminRole, CAMPUSES, type Campus, type PersonRow, YEARS } from "./people.contract"
+import { currentAdmin, formatDay, personName, telegramUrl, waitingForAuth } from "./people-format"
+import { useDialog, useDialogState } from "./people-hooks"
+import { ActionMenu, AssignmentBadge, PersonCell, RefusalText, TruncatedChip } from "./people-ui"
+import type { AdminSummary, CapoSummary, PersonRow } from "./people.contract"
 
-type Admin = PersonRow & { admin: AdminRole }
-type Scope = "active" | "former"
-type Year = (typeof YEARS)[number]
-type Quick = "availableAsCapo"
-type AdminDialog = { kind: "end" | "capoRef" | "capoScope" | "endCapo"; admin: Admin }
+type Tab = "admins" | "capos"
+type AdminDialog = { kind: "end" | "capoRef" | "appointCapo"; row: AdminSummary }
+type CapoDialog = { kind: "scope" | "end"; row: CapoSummary }
 
-function isAdmin(person: PersonRow): person is Admin {
-  return person.admin !== null
-}
-
-const QUICK = {
-  availableAsCapo: { label: "Available as Capo Admin", test: (person: Admin) => person.admin.availableAsCapo },
-} satisfies Record<Quick, { label: string; test: (person: Admin) => boolean }>
+const NO_CAPO = "none"
+const DEFAULT_SORT: TableSort = { column: "name", direction: "asc" }
 
-const QUICK_IDS = ["availableAsCapo"] satisfies Quick[]
+function TelegramButton({ person }: { person: PersonRow }) {
+  if (!person.telegramUsername) return <span aria-hidden className="size-9 max-shell:hidden" />
+  return (
+    <IconButton
+      label="Open in Telegram"
+      ariaLabel={`Open ${personName(person)} in Telegram`}
+      icon={Send}
+      iconNode={<PlatformGlyph platform="tg" className="size-4" />}
+      nativeButton={false}
+      render={<a href={telegramUrl(person.telegramUsername)} target="_blank" rel="noreferrer" />}
+    />
+  )
+}
 
-function matchesQuery(person: Admin, query: string) {
+function matches(person: PersonRow, query: string, extra: (string | null)[] = []) {
   if (!query) return true
-  return [personName(person), person.profile.course, person.profile.telegramUsername ?? ""].some((value) =>
-    value.toLocaleLowerCase().includes(query)
+  return [personName(person), person.telegramUsername ?? "", ...extra].some((value) =>
+    (value ?? "").toLocaleLowerCase().includes(query.replace(/^@/, ""))
   )
 }
 
-function tableColumns(): DataTableColumn<Admin>[] {
-  return [
-    {
-      id: "name",
-      label: "Name",
-      sortable: true,
-      fill: true,
-      minWidth: 220,
-      mobile: "main",
-      cell: (person) => (
-        <>
-          <PersonCell
-            name={personName(person)}
-            secondary={person.profile.course}
-            muted={person.admin.status === "former"}
-          />
-          {/* Mobile cards: the admin role on one line, then the Capo Admin scope. */}
-          <span className="mt-2 hidden flex-col items-start gap-1.5 pl-11 text-xs text-(--pn-fg-muted) max-shell:flex">
-            <span>
-              {person.admin.status !== "active" ? "Former admin" : `Admin since ${formatDay(person.admin.since)}`}
-            </span>
-            {person.admin.capoScope ? <Chip>Capo Admin · {person.admin.capoScope}</Chip> : null}
+const adminColumns: DataTableColumn<AdminSummary>[] = [
+  {
+    id: "name",
+    label: "Name",
+    sortable: true,
+    fill: true,
+    minWidth: 220,
+    mobile: "main",
+    cell: ({ person, admin, capo }) => (
+      <>
+        <PersonCell
+          name={personName(person)}
+          secondary={person.telegramUsername ? `@${person.telegramUsername}` : null}
+          secondaryMono
+        />
+        <span className="mt-2 hidden flex-wrap items-center gap-1.5 pl-11 max-shell:flex">
+          {capo?.capoScope ? <Chip>Capo Admin · {capo.capoScope}</Chip> : null}
+          {admin.capoOfReference ? (
+            <span className="text-xs text-(--pn-fg-muted)">Capo Admin: {admin.capoOfReference.name}</span>
+          ) : null}
+          <AssignmentBadge assignment={admin} />
+        </span>
+      </>
+    ),
+  },
+  {
+    id: "capoOfReference",
+    label: "Capo Admin of reference",
+    width: 208,
+    mobile: "hidden",
+    cell: ({ admin, capo }) =>
+      capo ? (
+        <TruncatedChip label={`Capo Admin · ${capo.capoScope ?? ""}`} />
+      ) : admin.capoOfReference ? (
+        <span className="block truncate">{admin.capoOfReference.name}</span>
+      ) : (
+        <Unset />
+      ),
+  },
+  {
+    id: "since",
+    label: "Since",
+    sortable: true,
+    width: 128,
+    priority: 4,
+    mobile: "hidden",
+    cell: ({ admin }) => <span className="whitespace-nowrap">{formatDay(admin.since)}</span>,
+  },
+  {
+    id: "status",
+    label: "With Auth",
+    width: 184,
+    priority: 3,
+    mobile: "hidden",
+    cell: ({ admin }) => <AssignmentBadge assignment={admin} showApplied />,
+  },
+]
+
+const capoColumns: DataTableColumn<CapoSummary>[] = [
+  {
+    id: "name",
+    label: "Name",
+    sortable: true,
+    fill: true,
+    minWidth: 220,
+    mobile: "main",
+    cell: ({ person, capo }) => (
+      <>
+        <PersonCell name={personName(person)} secondary={capo.capoScope} />
+        <span className="mt-2 hidden flex-wrap items-center gap-1.5 pl-11 max-shell:flex">
+          <AssignmentBadge assignment={capo} />
+        </span>
+        {capo.status === "refused" ? (
+          <span className="mt-1 block pl-11">
+            <RefusalText refusal={capo.refusal} />
           </span>
-        </>
+        ) : null}
+      </>
+    ),
+  },
+  {
+    id: "admins",
+    label: "Their admins",
+    width: 232,
+    mobile: "full",
+    cell: ({ admins }) =>
+      admins.length ? (
+        <ChipOverflow
+          items={admins.map((admin) => admin.name)}
+          max={2}
+          itemLabel={(admin) => admin}
+          renderItem={(admin) => <TruncatedChip key={admin} label={admin} />}
+        />
+      ) : (
+        <Unset />
       ),
-    },
-    {
-      id: "year",
-      label: "Year",
-      width: 112,
-      priority: 4,
-      mobile: "hidden",
-      cell: (person) => <span className="whitespace-nowrap">{person.profile.year}</span>,
-    },
-    {
-      id: "campus",
-      label: "Campus",
-      width: 112,
-      priority: 5,
-      mobile: "hidden",
-      cell: (person) => person.profile.campus,
-    },
-    {
-      id: "since",
-      label: "Active since",
-      sortable: true,
-      width: 128,
-      priority: 5,
-      mobile: "hidden",
-      cell: (person) =>
-        person.admin.status === "former" ? (
-          <span className="whitespace-nowrap text-(--pn-fg-muted)">Ended {formatDay(person.admin.endedOn ?? "")}</span>
-        ) : (
-          <span className="whitespace-nowrap">{formatDay(person.admin.since)}</span>
-        ),
-    },
-    {
-      id: "representative",
-      label: "Representative",
-      width: 184,
-      priority: 6,
-      mobile: "hidden",
-      cell: (person) =>
-        person.profile.studentRepresentative ? (
-          <span className="block truncate">{person.profile.studentRepresentative}</span>
-        ) : (
-          <Unset />
-        ),
-    },
-    {
-      id: "associations",
-      label: "Other associations",
-      width: 168,
-      priority: 6,
-      mobile: "hidden",
-      cell: (person) =>
-        person.profile.otherAssociations.length ? (
-          <ChipOverflow
-            items={person.profile.otherAssociations}
-            max={1}
-            itemLabel={(association) => association}
-            renderItem={(association) => <TruncatedChip key={association} label={association} />}
-          />
-        ) : (
-          <Unset />
-        ),
-    },
-    {
-      id: "availableAsCapo",
-      label: "Available as Capo",
-      width: 144,
-      priority: 6,
-      mobile: "hidden",
-      cell: (person) => (person.admin.availableAsCapo ? "Yes" : <Unset />),
-    },
-    {
-      id: "capoOfReference",
-      label: "Capo Admin of reference",
-      width: 184,
-      priority: 3,
-      mobile: "hidden",
-      cell: (person) =>
-        person.admin.capoScope ? (
-          <TruncatedChip label={`Capo Admin · ${person.admin.capoScope}`} />
-        ) : person.admin.capoOfReference ? (
-          <span className="block truncate">{person.admin.capoOfReference.name}</span>
-        ) : (
-          <Unset />
-        ),
-    },
-  ]
-}
+  },
+  {
+    id: "since",
+    label: "Since",
+    sortable: true,
+    width: 128,
+    priority: 4,
+    mobile: "hidden",
+    cell: ({ capo }) => <span className="whitespace-nowrap">{formatDay(capo.since)}</span>,
+  },
+  {
+    id: "status",
+    label: "With Auth",
+    width: 184,
+    priority: 3,
+    mobile: "hidden",
+    cell: ({ capo }) => <AssignmentBadge assignment={capo} showApplied />,
+  },
+]
 
-const DEFAULT_SORT: TableSort = { column: "name", direction: "asc" }
+function sortBy<T extends { person: PersonRow }>(rows: T[], sort: TableSort, since: (row: T) => string) {
+  const sign = sort.direction === "asc" ? 1 : -1
+  return rows.toSorted(
+    (a, b) =>
+      (sort.column === "since"
+        ? since(a).localeCompare(since(b))
+        : personName(a.person).localeCompare(personName(b.person))) * sign
+  )
+}
 
-/** People › Admins: admins of the Telegram course groups and their Capo Admin. */
-export function AdminsPage({ people }: { people: PersonRow[] }) {
+/**
+ * People › Admins: the current admins of the Telegram groups with their Capo Admin of reference, and the Capo Admins
+ * with their scope and admins. Each role shows where it stands with PoliNetwork Auth.
+ */
+export function AdminsPage({
+  admins,
+  capos,
+  people,
+}: {
+  admins: AdminSummary[]
+  capos: CapoSummary[]
+  people: PersonRow[]
+}) {
   const canWrite = useCan("people:write")
   const canAppoint = useCan("people:appoint")
-  const admins = people.filter(isAdmin)
-  const active = admins.filter((person) => person.admin.status === "active")
-
-  const [scope, setScope] = useState<Scope>("active")
-  const [campus, setCampus] = useState<Campus | null>(null)
-  const [year, setYear] = useState<Year | null>(null)
-  const [quick, setQuick] = useState<ReadonlySet<Quick>>(new Set())
+  const [tab, setTab] = useState<Tab>("admins")
+  const [capoFilter, setCapoFilter] = useState<string | null>(null)
   const [query, setQuery] = useState("")
   const deferredQuery = useDeferredValue(query.trim().toLocaleLowerCase())
   const [sort, setSort] = useState(DEFAULT_SORT)
   const [page, setPage] = useState(1)
   const [pageSize, setPageSize] = useState(20)
-  const [dialog, setDialog] = useState<AdminDialog | null>(null)
-  const [dialogOpen, setDialogOpen] = useState(false)
-  const dialogKey = useOpenGeneration(dialogOpen)
+  const assign = useDialogState()
+  const appoint = useDialogState()
+  const adminDialog = useDialog<AdminDialog>()
+  const capoDialog = useDialog<CapoDialog>()
 
-  const inScope = admins.filter((person) => person.admin.status === scope)
-  const filtered = inScope.filter(
-    (person) =>
-      (campus === null || person.profile.campus === campus) &&
-      (year === null || yearOf(person.profile.year) === year) &&
-      [...quick].every((id) => QUICK[id].test(person)) &&
-      matchesQuery(person, deferredQuery)
+  const filteredAdmins = admins.filter(
+    (row) =>
+      (capoFilter === null ||
+        (capoFilter === NO_CAPO
+          ? !row.admin.capoOfReference && !row.capo
+          : row.admin.capoOfReference?.id === capoFilter)) &&
+      matches(row.person, deferredQuery, [row.admin.capoOfReference?.name ?? null])
   )
-  const sign = sort.direction === "asc" ? 1 : -1
-  const sorted = filtered.toSorted(
-    (a, b) =>
-      (sort.column === "since"
-        ? a.admin.since.localeCompare(b.admin.since)
-        : personName(a).localeCompare(personName(b))) * sign
-  )
-  const rows = sorted.slice((page - 1) * pageSize, page * pageSize)
-  const narrowed = deferredQuery !== "" || campus !== null || year !== null || quick.size > 0
+  const filteredCapos = capos.filter((row) => matches(row.person, deferredQuery, [row.capo.capoScope]))
+  const sortedAdmins = sortBy(filteredAdmins, sort, (row) => row.admin.since)
+  const sortedCapos = sortBy(filteredCapos, sort, (row) => row.capo.since)
+  const total = tab === "admins" ? sortedAdmins.length : sortedCapos.length
+  const narrowed = deferredQuery !== "" || (tab === "admins" && capoFilter !== null)
+
+  const linked = (person: PersonRow) => person.account.status === "linked"
+  const option = (person: PersonRow) => ({ id: person.id, name: personName(person), linked: linked(person) })
+  const adminCandidates = people.filter((person) => !currentAdmin(person) && !waitingForAuth(person)).map(option)
+  const capoCandidates = admins
+    .filter((row) => !row.capo && !waitingForAuth(row.person))
+    .map((row) => option(row.person))
 
   function resetPage<T>(set: (value: T) => void) {
     return (value: T) => {
@@ -216,226 +242,288 @@ export function AdminsPage({ people }: { people: PersonRow[] }) {
     }
   }
 
-  function toggleQuick(id: Quick, pressed: boolean) {
-    setQuick((current) => {
-      const next = new Set(current)
-      if (pressed) next.add(id)
-      else next.delete(id)
-      return next
-    })
-    setPage(1)
-  }
-
   function clearFilters() {
     setQuery("")
-    setCampus(null)
-    setYear(null)
-    setQuick(new Set())
+    setCapoFilter(null)
     setPage(1)
   }
 
-  function open(kind: AdminDialog["kind"], admin: Admin) {
-    setDialog({ kind, admin })
-    setDialogOpen(true)
+  const pagination = {
+    page,
+    pageSize,
+    total,
+    onPage: setPage,
+    onPageSize: (size: number) => {
+      setPageSize(size)
+      setPage(1)
+    },
   }
+  const pageOf = <T,>(rows: T[]) => rows.slice((page - 1) * pageSize, page * pageSize)
 
-  const target: AdminTarget | null = dialog ? { personId: dialog.admin.id, name: personName(dialog.admin) } : null
+  const noMatch = (
+    <EmptyState
+      icon={ShieldUser}
+      title="Nothing matches"
+      text="Try another search or remove the filter."
+      action={
+        <Button size="sm" variant="ghost" className={buttonMotion} onClick={clearFilters}>
+          Clear filters
+        </Button>
+      }
+    />
+  )
 
   return (
     <>
       <PageBar
-        description={`${pluralize(active.length, "active admin")} of Telegram course groups`}
+        description={`${pluralize(admins.length, "admin")} · ${pluralize(capos.length, "Capo Admin")}`}
+        right={
+          tab === "admins" ? (
+            canWrite ? (
+              <Button size="sm" className={buttonMotion} onClick={assign.show}>
+                <ShieldPlus data-icon="inline-start" />
+                Make admin
+              </Button>
+            ) : undefined
+          ) : canAppoint ? (
+            <Button size="sm" className={buttonMotion} onClick={appoint.show}>
+              <Crown data-icon="inline-start" />
+              Appoint Capo Admin
+            </Button>
+          ) : undefined
+        }
         left={
           <Toolbar
             search={{
               value: query,
               onChange: resetPage(setQuery),
-              placeholder: "Search by name, course or username…",
+              placeholder: tab === "admins" ? "Search admins…" : "Search Capo Admins or scopes…",
             }}
             filters={
               <>
-                <SegmentedControl<Scope>
-                  label="Admin status"
+                <SegmentedControl<Tab>
+                  label="Show"
                   items={[
-                    { value: "active", label: "Active", count: active.length },
-                    { value: "former", label: "Former", count: admins.length - active.length },
+                    { value: "admins", label: "Admins", count: admins.length },
+                    { value: "capos", label: "Capo Admins", count: capos.length },
                   ]}
-                  value={scope}
-                  onValueChange={resetPage(setScope)}
+                  value={tab}
+                  onValueChange={(value) => {
+                    setTab(value)
+                    setSort(DEFAULT_SORT)
+                    setPage(1)
+                  }}
                 />
-                <FilterMenu<Campus>
-                  label="Campus"
-                  allLabel="All campuses"
-                  value={campus}
-                  onChange={resetPage(setCampus)}
-                  options={CAMPUSES.map((value) => ({ value, label: value }))}
-                />
-                <FilterMenu<Year>
-                  label="Year"
-                  allLabel="All years"
-                  value={year}
-                  onChange={resetPage(setYear)}
-                  options={YEARS.map((value) => ({ value, label: value }))}
-                />
-                {QUICK_IDS.map((id) => (
-                  <ToggleFilter
-                    key={id}
-                    label={QUICK[id].label}
-                    count={inScope.filter(QUICK[id].test).length}
-                    pressed={quick.has(id)}
-                    onPressedChange={(pressed) => toggleQuick(id, pressed)}
+                {tab === "admins" ? (
+                  <FilterMenu<string>
+                    label="Capo Admin"
+                    allLabel="Any Capo Admin"
+                    value={capoFilter}
+                    onChange={resetPage(setCapoFilter)}
+                    options={[
+                      {
+                        value: NO_CAPO,
+                        label: "No Capo Admin",
+                        count: admins.filter((row) => !row.admin.capoOfReference && !row.capo).length,
+                      },
+                      ...capos.map((row) => ({
+                        value: row.person.id,
+                        label: `${personName(row.person)}${row.capo.capoScope ? ` · ${row.capo.capoScope}` : ""}`,
+                        count: row.admins.length,
+                      })),
+                    ]}
                   />
-                ))}
+                ) : null}
               </>
             }
             count={
               narrowed ? (
-                <Count
-                  value={filtered.length}
-                  total={inScope.length}
-                  noun={scope === "former" ? "former admin" : "admin"}
-                  plural={scope === "former" ? "former admins" : "admins"}
-                />
+                tab === "admins" ? (
+                  <Count value={filteredAdmins.length} total={admins.length} noun="admin" plural="admins" />
+                ) : (
+                  <Count value={filteredCapos.length} total={capos.length} noun="Capo Admin" plural="Capo Admins" />
+                )
               ) : undefined
             }
           />
         }
       />
       <PageContent>
-        <DataTable
-          label="Admins"
-          columns={tableColumns()}
-          rows={rows}
-          getRowId={(person) => person.id}
-          rowLabel={personName}
-          rowHref={(person) => `/dashboard/people/${person.id}`}
-          rowProps={(person) => ({
-            className: person.admin.status === "former" ? "text-(--pn-fg-muted)" : undefined,
-          })}
-          sort={sort}
-          onSort={(next) => {
-            setSort(next)
-            setPage(1)
-          }}
-          actions={(person) => {
-            const activeAdmin = person.admin.status === "active"
-            return (
-              <RowActions>
-                {person.profile.telegramUsername ? (
-                  <IconButton
-                    label="Open in Telegram"
-                    ariaLabel={`Open ${personName(person)} in Telegram`}
-                    icon={Send}
-                    iconNode={<PlatformGlyph platform="tg" className="size-4" />}
-                    nativeButton={false}
-                    render={<a href={telegramUrl(person.profile.telegramUsername)} target="_blank" rel="noreferrer" />}
+        {tab === "admins" ? (
+          <DataTable
+            label="Admins"
+            columns={adminColumns}
+            rows={pageOf(sortedAdmins)}
+            getRowId={(row) => row.person.id}
+            rowLabel={(row) => personName(row.person)}
+            rowHref={(row) => `/dashboard/people/${row.person.id}`}
+            sort={sort}
+            onSort={resetPage(setSort)}
+            actions={(row) => {
+              const waiting = waitingForAuth(row.person)
+              return (
+                <RowActions>
+                  <TelegramButton person={row.person} />
+                  <ActionMenu
+                    keepSlot
+                    label={`More actions for ${personName(row.person)}`}
+                    actions={[
+                      canWrite &&
+                        !row.capo && {
+                          label: "Capo Admin of reference",
+                          ariaLabel: `Capo Admin of reference for ${personName(row.person)}`,
+                          icon: UserRoundCog,
+                          onClick: () => adminDialog.show({ kind: "capoRef", row }),
+                        },
+                      canAppoint &&
+                        !row.capo &&
+                        !waiting && {
+                          label: "Appoint as Capo Admin",
+                          ariaLabel: `Appoint ${personName(row.person)} as Capo Admin`,
+                          icon: Crown,
+                          onClick: () => adminDialog.show({ kind: "appointCapo", row }),
+                        },
+                      // A Capo Admin's appointment ends first, from Capo Admins.
+                      canWrite &&
+                        !row.capo &&
+                        !waiting && {
+                          label: "End admin role",
+                          ariaLabel: `End the admin role of ${personName(row.person)}`,
+                          icon: UserMinus,
+                          destructive: true,
+                          onClick: () => adminDialog.show({ kind: "end", row }),
+                        },
+                    ]}
                   />
-                ) : (
-                  <span aria-hidden className="size-9 max-shell:hidden" />
-                )}
+                </RowActions>
+              )
+            }}
+            actionsWidth={96}
+            pagination={pagination}
+            empty={
+              narrowed ? (
+                noMatch
+              ) : (
+                <EmptyState
+                  icon={ShieldUser}
+                  title="No admins yet"
+                  text="Admins appear here when you make someone an admin."
+                />
+              )
+            }
+          />
+        ) : (
+          <DataTable
+            label="Capo Admins"
+            columns={capoColumns}
+            rows={pageOf(sortedCapos)}
+            getRowId={(row) => row.person.id}
+            rowLabel={(row) => personName(row.person)}
+            rowHref={(row) => `/dashboard/people/${row.person.id}`}
+            sort={sort}
+            onSort={resetPage(setSort)}
+            actions={(row) => (
+              <RowActions>
+                <TelegramButton person={row.person} />
                 <ActionMenu
-                  label={`More actions for ${personName(person)}`}
+                  keepSlot
+                  label={`More actions for ${personName(row.person)}`}
                   actions={[
-                    canWrite &&
-                      activeAdmin &&
-                      !person.admin.capoScope && {
-                        label: "Capo Admin of reference",
-                        ariaLabel: `Capo Admin of reference for ${personName(person)}`,
-                        icon: UserRoundCog,
-                        onClick: () => open("capoRef", person),
-                      },
+                    canAppoint && {
+                      label: "Change scope",
+                      ariaLabel: `Change the scope of ${personName(row.person)}`,
+                      icon: Pencil,
+                      onClick: () => capoDialog.show({ kind: "scope", row }),
+                    },
                     canAppoint &&
-                      activeAdmin && {
-                        label: person.admin.capoScope ? "Change Capo Admin scope" : "Appoint as Capo Admin",
-                        ariaLabel: `${person.admin.capoScope ? "Change Capo Admin scope of" : "Appoint as Capo Admin"} ${personName(person)}`,
-                        icon: Crown,
-                        onClick: () => open("capoScope", person),
-                      },
-                    canAppoint &&
-                      activeAdmin &&
-                      person.admin.capoScope !== null && {
+                      !waitingForAuth(row.person) && {
                         label: "End Capo Admin role",
-                        ariaLabel: `End the Capo Admin role of ${personName(person)}`,
+                        ariaLabel: `End the Capo Admin role of ${personName(row.person)}`,
                         icon: Crown,
                         destructive: true,
-                        onClick: () => open("endCapo", person),
-                      },
-                    canWrite &&
-                      activeAdmin &&
-                      (canAppoint || person.admin.capoScope === null) && {
-                        label: "End admin role",
-                        ariaLabel: `End the admin role of ${personName(person)}`,
-                        icon: UserMinus,
-                        destructive: true,
-                        onClick: () => open("end", person),
+                        onClick: () => capoDialog.show({ kind: "end", row }),
                       },
                   ]}
                 />
               </RowActions>
-            )
-          }}
-          actionsWidth={96}
-          pagination={{
-            page,
-            pageSize,
-            total: sorted.length,
-            onPage: setPage,
-            onPageSize: (size) => {
-              setPageSize(size)
-              setPage(1)
-            },
-          }}
-          empty={
-            narrowed ? (
-              <EmptyState
-                icon={ShieldUser}
-                title="No admins match"
-                text="Try another search or remove a filter."
-                action={
-                  <Button size="sm" variant="ghost" className={buttonMotion} onClick={clearFilters}>
-                    Clear filters
-                  </Button>
-                }
-              />
-            ) : scope === "former" ? (
-              <EmptyState icon={ShieldUser} title="No former admins" text="Admins whose role ended appear here." />
-            ) : (
-              <EmptyState
-                icon={ShieldUser}
-                title="No admins yet"
-                text="Admins appear here when you add a person as admin."
-              />
-            )
-          }
-        />
+            )}
+            actionsWidth={96}
+            pagination={pagination}
+            empty={
+              narrowed ? (
+                noMatch
+              ) : (
+                <EmptyState
+                  icon={Crown}
+                  title="No Capo Admins yet"
+                  text="Appoint an admin as Capo Admin to coordinate other admins."
+                />
+              )
+            }
+          />
+        )}
       </PageContent>
-      {dialog && target ? (
-        dialog.kind === "end" ? (
-          <EndAdminDialog key={`end-${dialogKey}`} open={dialogOpen} onOpenChange={setDialogOpen} target={target} />
-        ) : dialog.kind === "capoRef" ? (
+      {canWrite ? (
+        <AssignAdminDialog
+          key={`assign-${assign.key}`}
+          open={assign.open}
+          onOpenChange={assign.onOpenChange}
+          candidates={adminCandidates}
+          capos={capos}
+        />
+      ) : null}
+      {canAppoint ? (
+        <AppointCapoDialog
+          key={`appoint-${appoint.key}`}
+          open={appoint.open}
+          onOpenChange={appoint.onOpenChange}
+          candidates={capoCandidates}
+        />
+      ) : null}
+      {adminDialog.target ? (
+        adminDialog.target.kind === "end" ? (
+          <EndAdminDialog
+            key={`end-${adminDialog.key}`}
+            open={adminDialog.open}
+            onOpenChange={adminDialog.onOpenChange}
+            target={{ personId: adminDialog.target.row.person.id, name: personName(adminDialog.target.row.person) }}
+            linked={linked(adminDialog.target.row.person)}
+          />
+        ) : adminDialog.target.kind === "capoRef" ? (
           <CapoOfReferenceDialog
-            key={`ref-${dialogKey}`}
-            open={dialogOpen}
-            onOpenChange={setDialogOpen}
-            target={target}
-            current={dialog.admin.admin.capoOfReference?.id ?? null}
-            people={people}
+            key={`ref-${adminDialog.key}`}
+            open={adminDialog.open}
+            onOpenChange={adminDialog.onOpenChange}
+            target={{ personId: adminDialog.target.row.person.id, name: personName(adminDialog.target.row.person) }}
+            current={adminDialog.target.row.admin.capoOfReference?.id ?? null}
+            capos={capos}
           />
-        ) : dialog.kind === "capoScope" ? (
+        ) : (
+          <AppointCapoDialog
+            key={`appoint-row-${adminDialog.key}`}
+            open={adminDialog.open}
+            onOpenChange={adminDialog.onOpenChange}
+            person={option(adminDialog.target.row.person)}
+          />
+        )
+      ) : null}
+      {capoDialog.target ? (
+        capoDialog.target.kind === "scope" ? (
           <CapoScopeDialog
-            key={`scope-${dialogKey}`}
-            open={dialogOpen}
-            onOpenChange={setDialogOpen}
-            target={target}
-            scope={dialog.admin.admin.capoScope}
+            key={`scope-${capoDialog.key}`}
+            open={capoDialog.open}
+            onOpenChange={capoDialog.onOpenChange}
+            target={{ personId: capoDialog.target.row.person.id, name: personName(capoDialog.target.row.person) }}
+            scope={capoDialog.target.row.capo.capoScope ?? ""}
           />
         ) : (
           <EndCapoDialog
-            key={`end-capo-${dialogKey}`}
-            open={dialogOpen}
-            onOpenChange={setDialogOpen}
-            target={target}
-            scope={dialog.admin.admin.capoScope ?? ""}
+            key={`end-capo-${capoDialog.key}`}
+            open={capoDialog.open}
+            onOpenChange={capoDialog.onOpenChange}
+            target={{ personId: capoDialog.target.row.person.id, name: personName(capoDialog.target.row.person) }}
+            linked={linked(capoDialog.target.row.person)}
+            scope={capoDialog.target.row.capo.capoScope ?? ""}
           />
         )
       ) : null}
diff --git a/src/features/people/capo-page.tsx b/src/features/people/capo-page.tsx
index 8dc015c..fdb4a6d 100644
--- a/src/features/people/capo-page.tsx
+++ b/src/features/people/capo-page.tsx
@@ -1,4 +1,4 @@
-import { MessageCircle, Send, ShieldUser } from "lucide-react"
+import { Send, ShieldUser } from "lucide-react"
 import { useDeferredValue, useState } from "react"
 
 import {
@@ -17,13 +17,68 @@ import { Count, PageBar, PageContent, Toolbar } from "@/components/shell"
 import { Button } from "@/components/ui/button"
 import { pluralize } from "@/lib/format"
 
-import { formatDay, personName, telegramUrl, whatsappUrl } from "./people-format"
-import { PersonCell } from "./people-ui"
+import { currentAdmin, formatDay, personName, telegramUrl } from "./people-format"
+import { AssignmentBadge, PersonCell } from "./people-ui"
 import type { CapoArea, PersonRow } from "./people.contract"
 
 const DEFAULT_SORT: TableSort = { column: "name", direction: "asc" }
 
-/** Telegram › Capo Admin: the admins who have the signed-in Capo Admin as Capo of reference. */
+const columns: DataTableColumn<PersonRow>[] = [
+  {
+    id: "name",
+    label: "Name",
+    sortable: true,
+    fill: true,
+    minWidth: 220,
+    mobile: "main",
+    cell: (person) => <PersonCell name={personName(person)} />,
+  },
+  {
+    id: "since",
+    label: "Admin since",
+    sortable: true,
+    width: 136,
+    priority: 3,
+    mobile: "meta",
+    cell: (person) => {
+      const admin = currentAdmin(person)
+      return admin ? <span className="whitespace-nowrap">{formatDay(admin.since)}</span> : <Unset />
+    },
+  },
+  {
+    id: "telegram",
+    label: "Telegram",
+    width: 200,
+    priority: 2,
+    mobile: "meta",
+    cell: (person) =>
+      person.telegramUsername ? (
+        <span className="flex min-w-0 items-center gap-1.5">
+          <PlatformGlyph platform="tg" className="size-3.5 shrink-0" />
+          <span className="truncate font-mono text-[13px]">@{person.telegramUsername}</span>
+        </span>
+      ) : (
+        <Unset />
+      ),
+  },
+  {
+    id: "status",
+    label: "With Auth",
+    width: 184,
+    priority: 4,
+    mobile: "meta",
+    cell: (person) => {
+      const admin = currentAdmin(person)
+      return admin ? <AssignmentBadge assignment={admin} /> : null
+    },
+  },
+]
+
+/**
+ * Telegram › Capo Admin: the admins who have the signed-in Capo Admin as Capo Admin of reference. Read-only for now.
+ * Managing them ("a Capo Admin adds and removes their admins", PoliNetworkOrg/admin#143) would add a page action
+ * next to the heading and row actions to this table, the way People › Admins has them.
+ */
 export function CapoPage({ area }: { area: CapoArea }) {
   const [query, setQuery] = useState("")
   const deferredQuery = useDeferredValue(query.trim().toLocaleLowerCase())
@@ -34,175 +89,100 @@ export function CapoPage({ area }: { area: CapoArea }) {
   const filtered = area.admins.filter(
     (person) =>
       !deferredQuery ||
-      [personName(person), person.profile.telegramUsername ?? ""].some((value) =>
-        value.toLocaleLowerCase().includes(deferredQuery)
+      [personName(person), person.telegramUsername ?? ""].some((value) =>
+        value.toLocaleLowerCase().includes(deferredQuery.replace(/^@/, ""))
       )
   )
   const sign = sort.direction === "asc" ? 1 : -1
-  const sorted = filtered.toSorted((a, b) => personName(a).localeCompare(personName(b)) * sign)
+  const sorted = filtered.toSorted(
+    (a, b) =>
+      (sort.column === "since"
+        ? (currentAdmin(a)?.since ?? "").localeCompare(currentAdmin(b)?.since ?? "")
+        : personName(a).localeCompare(personName(b))) * sign
+  )
   const rows = sorted.slice((page - 1) * pageSize, page * pageSize)
 
-  const columns: DataTableColumn<PersonRow>[] = [
-    {
-      id: "name",
-      label: "Name",
-      sortable: true,
-      fill: true,
-      minWidth: 220,
-      mobile: "main",
-      cell: (person) => <PersonCell name={personName(person)} secondary={person.profile.course} />,
-    },
-    {
-      id: "year",
-      label: "Year",
-      width: 112,
-      priority: 3,
-      mobile: "hidden",
-      cell: (person) => <span className="whitespace-nowrap">{person.profile.year}</span>,
-    },
-    {
-      id: "since",
-      label: "Active since",
-      width: 128,
-      priority: 4,
-      mobile: "hidden",
-      cell: (person) =>
-        person.admin ? <span className="whitespace-nowrap">{formatDay(person.admin.since)}</span> : <Unset />,
-    },
-    {
-      id: "representative",
-      label: "Representative",
-      width: 168,
-      priority: 5,
-      mobile: "hidden",
-      cell: (person) =>
-        person.profile.studentRepresentative ? (
-          <span className="block truncate">{person.profile.studentRepresentative}</span>
-        ) : (
-          <Unset />
-        ),
-    },
-    {
-      id: "phone",
-      label: "Phone",
-      width: 152,
-      mobile: "meta",
-      cell: (person) =>
-        person.profile.phone ? <span className="whitespace-nowrap">{person.profile.phone}</span> : <Unset />,
-    },
-    {
-      id: "telegram",
-      label: "Telegram",
-      width: 176,
-      priority: 3,
-      mobile: "meta",
-      cell: (person) =>
-        person.profile.telegramUsername ? (
-          <span className="flex min-w-0 items-center gap-1.5">
-            <PlatformGlyph platform="tg" className="size-3.5 shrink-0" />
-            <span className="truncate font-mono text-[13px]">@{person.profile.telegramUsername}</span>
-          </span>
-        ) : (
-          <Unset />
-        ),
-    },
-  ]
-
   return (
     <>
-      <PageBar description={`${area.scope} · ${pluralize(area.admins.length, "admin")}`} />
+      <PageBar description={`Capo Admin of ${area.scope} · ${pluralize(area.admins.length, "admin")}`} />
       <PageContent>
-        <div className="flex flex-col gap-8">
-          <section className="flex flex-col gap-3" aria-labelledby="capo-admins">
-            <SectionHeading id="capo-admins" title="My admins" count={area.admins.length} />
-            <Toolbar
-              search={{
-                value: query,
-                onChange: (value) => {
-                  setQuery(value)
-                  setPage(1)
-                },
-                placeholder: "Search admins…",
-              }}
-              count={
-                deferredQuery ? (
-                  <Count value={filtered.length} total={area.admins.length} noun="admin" plural="admins" />
-                ) : undefined
-              }
-            />
-            <DataTable
-              label="My admins"
-              columns={columns}
-              rows={rows}
-              getRowId={(person) => person.id}
-              rowLabel={personName}
-              sort={sort}
-              onSort={(next) => {
-                setSort(next)
+        <section className="flex flex-col gap-3" aria-labelledby="capo-admins">
+          <SectionHeading id="capo-admins" title="My admins" count={area.admins.length} />
+          <Toolbar
+            search={{
+              value: query,
+              onChange: (value) => {
+                setQuery(value)
                 setPage(1)
-              }}
-              actions={(person) => (
-                <RowActions>
-                  {person.profile.telegramUsername ? (
-                    <IconButton
-                      label="Open in Telegram"
-                      ariaLabel={`Open ${personName(person)} in Telegram`}
-                      icon={Send}
-                      iconNode={<PlatformGlyph platform="tg" className="size-4" />}
-                      nativeButton={false}
-                      render={
-                        <a href={telegramUrl(person.profile.telegramUsername)} target="_blank" rel="noreferrer" />
-                      }
-                    />
-                  ) : (
-                    <span aria-hidden className="size-9 max-shell:hidden" />
-                  )}
-                  {person.profile.phone ? (
-                    <IconButton
-                      label="Open in WhatsApp"
-                      ariaLabel={`Open ${personName(person)} in WhatsApp`}
-                      icon={MessageCircle}
-                      iconNode={<PlatformGlyph platform="wa" className="size-4" />}
-                      nativeButton={false}
-                      render={<a href={whatsappUrl(person.profile.phone)} target="_blank" rel="noreferrer" />}
-                    />
-                  ) : null}
-                </RowActions>
-              )}
-              actionsWidth={96}
-              pagination={{
-                page,
-                pageSize,
-                total: sorted.length,
-                onPage: setPage,
-                onPageSize: (size) => {
-                  setPageSize(size)
-                  setPage(1)
-                },
-              }}
-              empty={
-                deferredQuery ? (
-                  <EmptyState
-                    icon={ShieldUser}
-                    title="No admins match"
-                    text="Try another name or username."
-                    action={
-                      <Button size="sm" variant="ghost" className={buttonMotion} onClick={() => setQuery("")}>
-                        Clear search
-                      </Button>
-                    }
+              },
+              placeholder: "Search admins…",
+            }}
+            count={
+              deferredQuery ? (
+                <Count value={filtered.length} total={area.admins.length} noun="admin" plural="admins" />
+              ) : undefined
+            }
+          />
+          <DataTable
+            label="My admins"
+            columns={columns}
+            rows={rows}
+            getRowId={(person) => person.id}
+            rowLabel={personName}
+            sort={sort}
+            onSort={(next) => {
+              setSort(next)
+              setPage(1)
+            }}
+            actions={(person) => (
+              <RowActions>
+                {person.telegramUsername ? (
+                  <IconButton
+                    label="Open in Telegram"
+                    ariaLabel={`Open ${personName(person)} in Telegram`}
+                    icon={Send}
+                    iconNode={<PlatformGlyph platform="tg" className="size-4" />}
+                    nativeButton={false}
+                    render={<a href={telegramUrl(person.telegramUsername)} target="_blank" rel="noreferrer" />}
                   />
                 ) : (
-                  <EmptyState
-                    icon={ShieldUser}
-                    title="No admins yet"
-                    text="Admins appear here once you are set as their Capo of reference."
-                  />
-                )
-              }
-            />
-          </section>
-        </div>
+                  <span aria-hidden className="size-9 max-shell:hidden" />
+                )}
+              </RowActions>
+            )}
+            actionsWidth={96}
+            pagination={{
+              page,
+              pageSize,
+              total: sorted.length,
+              onPage: setPage,
+              onPageSize: (size) => {
+                setPageSize(size)
+                setPage(1)
+              },
+            }}
+            empty={
+              deferredQuery ? (
+                <EmptyState
+                  icon={ShieldUser}
+                  title="No admins match"
+                  text="Try another name or username."
+                  action={
+                    <Button size="sm" variant="ghost" className={buttonMotion} onClick={() => setQuery("")}>
+                      Clear search
+                    </Button>
+                  }
+                />
+              ) : (
+                <EmptyState
+                  icon={ShieldUser}
+                  title="No admins yet"
+                  text="Admins appear here once HR sets you as their Capo Admin of reference."
+                />
+              )
+            }
+          />
+        </section>
       </PageContent>
     </>
   )
diff --git a/src/features/people/link-account-dialog.tsx b/src/features/people/link-account-dialog.tsx
index ed874ea..73aa17b 100644
--- a/src/features/people/link-account-dialog.tsx
+++ b/src/features/people/link-account-dialog.tsx
@@ -6,7 +6,6 @@ import {
   fieldHintId,
   FormDialog,
   FormField,
-  PlatformGlyph,
   RadioCard,
   RadioCardGroup,
   Spinner,
@@ -17,19 +16,16 @@ import { Textarea } from "@/components/ui/textarea"
 import { cn } from "@/lib/utils"
 
 import { errorMessage, useLoaded, useRefreshAfter } from "./people-hooks"
+import { linkPersonAccount, searchPeopleAccounts, unlinkPersonAccount } from "./people-link.functions"
 import { PersonAvatar } from "./people-ui"
-import { linkPersonAccount } from "./people-write.functions"
-import { searchPeopleAccounts } from "./people.functions"
+import { UNLINK_REASON } from "./people.contract"
 
 const LINK_ERROR = "Couldn't link account."
 
-const REASONS = {
-  "same-telegram": { label: "Same verified Telegram account", tone: "success" },
-  "same-email": { label: "Same email", tone: "success" },
-  "similar-name": { label: "Similar name — check before linking", tone: "warning" },
-} as const
-
-/** Connect a sign-in account to a person's record, with the reason saved in its activity. */
+/**
+ * Links a sign-in account from the IdP directory to a record, with the reason saved in its activity. Nothing is
+ * matched automatically: whoever links checks the account is theirs. The record's pending roles then go to Auth.
+ */
 export function LinkAccountDialog({
   open,
   onOpenChange,
@@ -49,10 +45,7 @@ export function LinkAccountDialog({
   const [submitted, setSubmitted] = useState(false)
 
   const { data: accounts, failed } = useLoaded(
-    useMemo(
-      () => (open ? () => search({ data: { personId: person.id, query: deferredQuery } }) : null),
-      [open, person.id, deferredQuery, search]
-    ),
+    useMemo(() => (open ? () => search({ data: { query: deferredQuery } }) : null), [open, deferredQuery, search]),
     true
   )
   const loadError = failed ? "Couldn't load accounts. Try again." : null
@@ -62,6 +55,8 @@ export function LinkAccountDialog({
   async function submit() {
     setSubmitted(true)
     if (!selected) throw new Error("Choose an account to link.")
+    if (accounts?.find((account) => account.id === selected)?.linkedTo)
+      throw new Error("That account is linked to another record.")
     if (!reason.trim()) return
     try {
       await link({ data: { personId: person.id, accountId: selected, reason: reason.trim() } })
@@ -69,7 +64,7 @@ export function LinkAccountDialog({
       console.error(caught)
       throw new Error(`${LINK_ERROR} ${errorMessage(caught, "")}`.trim(), { cause: caught })
     }
-    await refresh("Account linked.")
+    await refresh("Account linked. PoliNetwork Auth applies the record's roles shortly.")
     onOpenChange(false)
   }
 
@@ -78,7 +73,7 @@ export function LinkAccountDialog({
       open={open}
       onOpenChange={onOpenChange}
       title="Link account"
-      description={`Connect a PoliNetwork sign-in to ${person.name} (${person.id}). They can then see their record in My area.`}
+      description={`Connect a sign-in account to ${person.name} (${person.id}). Their pending roles go to PoliNetwork Auth, acting as you, and they can see their record in My area.`}
       noun="link"
       dirty={selected !== null || reason.trim() !== ""}
       submitLabel="Link account"
@@ -90,7 +85,7 @@ export function LinkAccountDialog({
           value={query}
           onChange={setQuery}
           label="Search accounts"
-          placeholder="Search accounts by name, email or Telegram…"
+          placeholder="Search accounts by name or email…"
           className="w-full max-w-none"
         />
         <div className="flex flex-col gap-2">
@@ -98,15 +93,11 @@ export function LinkAccountDialog({
           {accounts === null && !loadError ? <Spinner className="size-4" /> : null}
           {accounts?.length === 0 ? (
             <p className="text-[13px] text-(--pn-fg-muted)">
-              No accounts match. Check the spelling, or send an invite.
+              No accounts match. Check the spelling, or send an invite: they can accept it with any account.
             </p>
           ) : null}
           {accounts?.length ? (
-            <RadioCardGroup
-              label={deferredQuery ? "Accounts" : "Suggested matches"}
-              value={selected}
-              onValueChange={setSelected}
-            >
+            <RadioCardGroup label="Accounts" value={selected} onValueChange={setSelected}>
               {accounts.map((account) => (
                 <RadioCard
                   key={account.id}
@@ -115,20 +106,15 @@ export function LinkAccountDialog({
                   label={account.name}
                   description={
                     <span className="flex flex-col gap-0.5">
-                      <span className="font-mono [overflow-wrap:anywhere]">{account.email}</span>
-                      <span className="flex flex-wrap items-center gap-1.5">
-                        {account.telegram ? (
-                          <>
-                            <PlatformGlyph platform="tg" className="size-3" />
-                            <span className="font-mono">{account.telegram}</span>
-                            <span aria-hidden>·</span>
-                          </>
-                        ) : null}
-                        {account.linkedTo ? `Linked to ${account.linkedTo.name} (${account.linkedTo.id})` : account.via}
-                      </span>
+                      <span className="font-mono [overflow-wrap:anywhere]">{account.email || account.id}</span>
+                      {account.linkedTo ? (
+                        <span>
+                          Linked to {account.linkedTo.name} ({account.linkedTo.id})
+                        </span>
+                      ) : null}
                     </span>
                   }
-                  end={<StatusBadge tone={REASONS[account.reason].tone}>{REASONS[account.reason].label}</StatusBadge>}
+                  end={account.linkedTo ? <StatusBadge tone="neutral">Linked</StatusBadge> : undefined}
                 />
               ))}
             </RadioCardGroup>
@@ -149,3 +135,78 @@ export function LinkAccountDialog({
     </FormDialog>
   )
 }
+
+/**
+ * Unlinks a record's account. Auth takes the record's roles back first; once it confirms, the account is detached and
+ * the roles wait as pending for the next link. If Auth refuses, the account stays linked with its roles.
+ */
+export function UnlinkAccountDialog({
+  open,
+  onOpenChange,
+  person,
+}: {
+  open: boolean
+  onOpenChange: (open: boolean) => void
+  person: { id: string; name: string; roles: number }
+}) {
+  const unlink = useServerFn(unlinkPersonAccount)
+  const refresh = useRefreshAfter()
+  const [reason, setReason] = useState("")
+  const [submitted, setSubmitted] = useState(false)
+  const max = 500 - UNLINK_REASON.length
+  const reasonError = submitted && !reason.trim() ? "Enter a reason." : undefined
+
+  async function submit() {
+    setSubmitted(true)
+    if (!reason.trim()) return
+    try {
+      await unlink({ data: { personId: person.id, reason: reason.trim() } })
+    } catch (caught) {
+      console.error(caught)
+      throw new Error(errorMessage(caught, "Couldn't unlink the account."), { cause: caught })
+    }
+    await refresh(
+      person.roles
+        ? "Unlinking: PoliNetwork Auth takes the roles back, then the account is detached."
+        : "Account unlinked."
+    )
+    onOpenChange(false)
+  }
+
+  return (
+    <FormDialog
+      open={open}
+      onOpenChange={onOpenChange}
+      title="Unlink account?"
+      description={
+        person.roles
+          ? `PoliNetwork Auth revokes ${person.name}'s roles from this account, then the account is detached. The roles stay on the record as pending, and are given again when an account is linked. If Auth refuses, nothing changes.`
+          : `The account is detached from ${person.name}'s record. The record and its history stay.`
+      }
+      noun="unlink"
+      dirty={reason.trim() !== ""}
+      submitLabel="Unlink account"
+      tone="danger"
+      onSubmit={submit}
+    >
+      <FormField
+        label="Reason"
+        htmlFor="unlink-reason"
+        hint="Saved in the record's activity and sent to PoliNetwork Auth."
+        error={reasonError}
+        counter={{ length: reason.length, max }}
+      >
+        <Textarea
+          id="unlink-reason"
+          value={reason}
+          maxLength={max}
+          onChange={(event) => setReason(event.target.value)}
+          placeholder="e.g. Linked to the wrong account"
+          aria-invalid={reasonError ? true : undefined}
+          aria-describedby={fieldHintId("unlink-reason")}
+          className={cn(fieldControl, "min-h-20")}
+        />
+      </FormField>
+    </FormDialog>
+  )
+}
diff --git a/src/features/people/my-area-page.tsx b/src/features/people/my-area-page.tsx
index 09533ba..bf448f6 100644
--- a/src/features/people/my-area-page.tsx
+++ b/src/features/people/my-area-page.tsx
@@ -1,6 +1,6 @@
 import { Link, useNavigate } from "@tanstack/react-router"
 import { useServerFn } from "@tanstack/react-start"
-import { Camera, ChevronRight, Crown, FileText, Send, UserRound, Users, UsersRound } from "lucide-react"
+import { ChevronRight, Crown, Send, ShieldUser, UserRound, Users, UsersRound } from "lucide-react"
 import { useState } from "react"
 
 import {
@@ -15,7 +15,6 @@ import {
   PlatformGlyph,
   SectionCard,
   SectionHeading,
-  StatusBadge,
   Unset,
 } from "@/components/primitives"
 import { appToast, PageBar, PageContent, useCan } from "@/components/shell"
@@ -23,17 +22,18 @@ import { Button } from "@/components/ui/button"
 
 import { MyFeeCard } from "./my-fee-card"
 import {
-  activeTeams,
+  assignmentLabel,
   formatDay,
-  isActiveAdmin,
+  isTeamAssignment,
+  LINK_METHOD,
+  openAssignments,
   personName,
-  PHOTO_CONSENT,
   teamName,
   telegramUrl,
 } from "./people-format"
 import { errorMessage, useRefreshAfter } from "./people-hooks"
 import { acceptMyInvite } from "./people-self.functions"
-import { PersonAvatar, PersonCell, Row, RowIcon, Rows, StateBadge } from "./people-ui"
+import { AssignmentBadge, PersonAvatar, PersonCell, RefusalText, Row, RowIcon, Rows } from "./people-ui"
 import type { MyArea } from "./people.contract"
 
 type Linked = Extract<MyArea, { state: "linked" }>
@@ -85,8 +85,8 @@ function InviteView({ token }: { token: string }) {
           }
         >
           <p className="text-[14px] text-(--pn-fg-muted)">
-            HR invited you to link this sign-in to your PoliNetwork record, so you can see your roles. Use the account
-            with the email address the invite was sent to.
+            HR invited you to link this sign-in to your PoliNetwork record, so you get your roles. You can use any
+            account, not only the one at the address the invite was sent to. The link works once.
           </p>
         </SectionCard>
       </PageContent>
@@ -113,32 +113,32 @@ function LinkedView({ area }: { area: Linked }) {
   const { person, contacts, roster } = area
   // The fee card is an unconnected mockup (Phase 2, #144), shown only to People readers.
   const canRead = useCan("people:read")
-  const { profile, admin, consents } = person
-  const teams = activeTeams(person)
+  const roles = openAssignments(person)
   const name = personName(person)
 
   const profileItems: KeyValueItem[] = [
     {
-      key: "Personal email",
-      value: profile.personalEmail ? <span className="[overflow-wrap:anywhere]">{profile.personalEmail}</span> : null,
+      key: "Contact email",
+      value: person.contactEmail ? <span className="[overflow-wrap:anywhere]">{person.contactEmail}</span> : null,
     },
-    { key: "Phone", value: profile.phone },
+    { key: "Phone", value: person.phone },
     {
       key: "Telegram",
-      value: profile.telegramUsername ? (
+      value: person.telegramUsername ? (
         <span className="inline-flex items-center gap-1.5 font-mono">
-          <PlatformGlyph platform="tg" className="size-3.5" />@{profile.telegramUsername}
+          <PlatformGlyph platform="tg" className="size-3.5" />@{person.telegramUsername}
         </span>
       ) : null,
     },
-    { key: "Course", value: profile.course },
-    { key: "Year", value: profile.year },
-    { key: "Campus", value: <Chip>{profile.campus}</Chip> },
     ...(person.account.status === "linked"
       ? [
           {
-            key: "PoliNetwork account",
-            value: <span className="font-mono [overflow-wrap:anywhere]">{person.account.email}</span>,
+            key: "Linked account",
+            value: <span className="font-mono [overflow-wrap:anywhere]">{person.account.sub}</span>,
+          },
+          {
+            key: "Linked",
+            value: `${LINK_METHOD[person.account.method]}${person.account.linkedOn ? ` · ${formatDay(person.account.linkedOn)}` : ""}`,
           },
         ]
       : []),
@@ -192,52 +192,87 @@ function LinkedView({ area }: { area: Linked }) {
           <div className="grid items-start gap-4 min-[1100px]:grid-cols-2">
             <div className="flex min-w-0 flex-col gap-4">
               <SectionCard title="My roles" padding="flush">
-                {isActiveAdmin(person) || admin?.capoScope || teams.length ? (
+                {roles.length ? (
                   <Rows>
-                    {admin && isActiveAdmin(person) ? (
+                    {roles.map((assignment) => (
                       <Row
+                        key={assignment.id}
                         lead={
-                          <span className="grid size-8 place-items-center rounded-(--pn-r-3) bg-(--pn-muted)">
-                            <PlatformGlyph platform="tg" className="size-4" />
-                          </span>
-                        }
-                        title="Admin"
-                        meta={`Since ${formatDay(admin.since)}`}
-                      />
-                    ) : null}
-                    {admin?.capoScope ? (
-                      <Row
-                        lead={<RowIcon icon={Crown} />}
-                        title="Capo Admin"
-                        meta={admin.capoScope}
-                        end={
-                          <IconButton
-                            label="Open Capo Admin"
-                            icon={ChevronRight}
-                            nativeButton={false}
-                            render={<Link to="/dashboard/telegram/capo" />}
+                          <RowIcon
+                            icon={assignment.kind === "admin" ? ShieldUser : assignment.kind === "capo" ? Crown : Users}
                           />
                         }
-                      />
-                    ) : null}
-                    {teams.map((membership) => (
-                      <Row
-                        key={membership.team}
-                        lead={<RowIcon icon={Users} />}
                         title={
+                          isTeamAssignment(assignment) ? (
+                            <>
+                              {teamName(assignment.team)}
+                              <Chip>{assignment.teamRole === "lead" ? "Lead" : "Member"}</Chip>
+                            </>
+                          ) : (
+                            assignmentLabel(assignment)
+                          )
+                        }
+                        meta={`Since ${formatDay(assignment.since)}`}
+                        detail={
+                          assignment.status === "refused" ? <RefusalText refusal={assignment.refusal} /> : undefined
+                        }
+                        end={
                           <>
-                            {teamName(membership.team)}
-                            <Chip>{membership.role === "lead" ? "Lead" : "Member"}</Chip>
+                            <AssignmentBadge assignment={assignment} />
+                            {assignment.status === "applied" && assignment.kind === "capo" ? (
+                              <IconButton
+                                label="Open Capo Admin"
+                                icon={ChevronRight}
+                                nativeButton={false}
+                                render={<Link to="/dashboard/telegram/capo" />}
+                              />
+                            ) : null}
+                            {assignment.status === "applied" &&
+                            isTeamAssignment(assignment) &&
+                            assignment.teamRole === "lead" ? (
+                              <IconButton
+                                label="Open your team"
+                                icon={ChevronRight}
+                                nativeButton={false}
+                                render={<Link to="/dashboard/people/teams" />}
+                              />
+                            ) : null}
                           </>
                         }
-                        meta={`Since ${formatDay(membership.since)}`}
+                      />
+                    ))}
+                  </Rows>
+                ) : (
+                  <p className="px-4 py-3 text-[13px] text-(--pn-fg-muted)">No current roles.</p>
+                )}
+              </SectionCard>
+
+              <SectionCard title="People to contact" padding="flush">
+                {contacts.length ? (
+                  <Rows>
+                    {contacts.map((contact) => (
+                      <Row
+                        key={`${contact.role}-${contact.name}-${contact.team ?? ""}`}
+                        lead={
+                          contact.role === "hr" ? <RowIcon icon={UsersRound} /> : <PersonAvatar name={contact.name} />
+                        }
+                        title={contact.name}
+                        meta={
+                          contact.role === "capo"
+                            ? "Your Capo Admin"
+                            : contact.role === "lead"
+                              ? `Your Team Lead · ${contact.team ? teamName(contact.team) : ""}`
+                              : "HR, for anything about your record"
+                        }
                         end={
-                          membership.role === "lead" ? (
+                          contact.telegram ? (
                             <IconButton
-                              label="Open your team"
-                              icon={ChevronRight}
+                              label="Open in Telegram"
+                              ariaLabel={`Open ${contact.name} in Telegram`}
+                              icon={Send}
+                              iconNode={<PlatformGlyph platform="tg" className="size-4" />}
                               nativeButton={false}
-                              render={<Link to="/dashboard/people/teams" />}
+                              render={<a href={telegramUrl(contact.telegram)} target="_blank" rel="noreferrer" />}
                             />
                           ) : undefined
                         }
@@ -245,71 +280,15 @@ function LinkedView({ area }: { area: Linked }) {
                     ))}
                   </Rows>
                 ) : (
-                  <p className="px-4 py-3 text-[13px] text-(--pn-fg-muted)">No active roles.</p>
+                  <p className="px-4 py-3 text-[13px] text-(--pn-fg-muted)">Nobody to list yet.</p>
                 )}
               </SectionCard>
-
-              <SectionCard title="People to contact" padding="flush">
-                <Rows>
-                  {contacts.map((contact) => (
-                    <Row
-                      key={`${contact.role}-${contact.name}-${contact.team ?? ""}`}
-                      lead={
-                        contact.role === "hr" ? <RowIcon icon={UsersRound} /> : <PersonAvatar name={contact.name} />
-                      }
-                      title={contact.name}
-                      meta={
-                        contact.role === "capo"
-                          ? "Your Capo Admin"
-                          : contact.role === "lead"
-                            ? `Your Team Lead · ${contact.team ? teamName(contact.team) : ""}`
-                            : "For anything about your record"
-                      }
-                      end={
-                        contact.telegram ? (
-                          <IconButton
-                            label="Open in Telegram"
-                            ariaLabel={`Open ${contact.name} in Telegram`}
-                            icon={Send}
-                            iconNode={<PlatformGlyph platform="tg" className="size-4" />}
-                            nativeButton={false}
-                            render={<a href={telegramUrl(contact.telegram)} target="_blank" rel="noreferrer" />}
-                          />
-                        ) : undefined
-                      }
-                    />
-                  ))}
-                </Rows>
-              </SectionCard>
             </div>
 
             <div className="flex min-w-0 flex-col gap-4">
-              <SectionCard title="My profile">
+              <SectionCard title="My record">
                 <KeyValueList items={profileItems} />
               </SectionCard>
-
-              <SectionCard title="My consents" padding="flush">
-                <Rows>
-                  {consents.privacy ? (
-                    <Row
-                      lead={<RowIcon icon={FileText} />}
-                      title="Volunteer privacy policy"
-                      meta={`Version ${consents.privacy.version} · accepted ${formatDay(consents.privacy.acceptedOn)}`}
-                      end={<StatusBadge tone="success">Accepted</StatusBadge>}
-                    />
-                  ) : null}
-                  <Row
-                    lead={<RowIcon icon={Camera} />}
-                    title="Photo and video"
-                    meta={
-                      consents.photo
-                        ? `${PHOTO_CONSENT[consents.photo.status].label} ${formatDay(consents.photo.on)}`
-                        : "Not granted"
-                    }
-                    end={<StateBadge state={PHOTO_CONSENT[consents.photo?.status ?? "denied"]} />}
-                  />
-                </Rows>
-              </SectionCard>
             </div>
           </div>
 
diff --git a/src/features/people/overview-page.tsx b/src/features/people/overview-page.tsx
index fa60d40..9da2e1c 100644
--- a/src/features/people/overview-page.tsx
+++ b/src/features/people/overview-page.tsx
@@ -11,6 +11,7 @@ import {
   FilterMenu,
   IconButton,
   RowActions,
+  StatusBadge,
   type TableSort,
   Unset,
   useOpenGeneration,
@@ -23,9 +24,11 @@ import { type AccountAction, AccountActionDialog } from "./account-action-dialog
 import { LinkAccountDialog } from "./link-account-dialog"
 import {
   ACCOUNT_STATUS,
-  activeTeams,
+  currentAdmin,
+  currentCapo,
+  currentTeams,
   hasNoRoles,
-  isActiveAdmin,
+  openRefusals,
   personName,
   roleLabels,
   teamName,
@@ -34,45 +37,68 @@ import { ActionMenu, PersonCell, StateBadge, TruncatedChip } from "./people-ui"
 import {
   ACCOUNT_STATUSES,
   type AccountStatus,
-  CAMPUSES,
-  type Campus,
   type PersonRow,
   TEAM_IDS,
   type TeamId,
+  type TeamSummary,
 } from "./people.contract"
 import { PersonDialog } from "./person-dialog"
 
-type RoleFilter = "admin" | "team" | "none"
+type RoleFilter = "admin" | "capo" | "team" | "none"
+type ChangeFilter = "pending" | "sent" | "refused"
 type Filters = {
   role: RoleFilter | null
   team: TeamId | null
-  campus: Campus | null
   account: AccountStatus | null
+  change: ChangeFilter | null
 }
 
-const NO_FILTERS: Filters = { role: null, team: null, campus: null, account: null }
+const NO_FILTERS: Filters = { role: null, team: null, account: null, change: null }
 
 const ROLE_TEST = {
-  admin: isActiveAdmin,
-  team: (person) => activeTeams(person).length > 0,
+  admin: (person) => currentAdmin(person) !== null,
+  capo: (person) => currentCapo(person) !== null,
+  team: (person) => currentTeams(person).length > 0,
   none: hasNoRoles,
 } satisfies Record<RoleFilter, (person: PersonRow) => boolean>
 
+/** Roles waiting for a link, waiting for Auth, or refused by Auth (and not assigned again). */
+const CHANGE_TEST = {
+  pending: (person) => person.assignments.some((a) => a.endedOn === null && a.status === "pending"),
+  sent: (person) => person.assignments.some((a) => a.status === "sent"),
+  refused: (person) => openRefusals(person).length > 0,
+} satisfies Record<ChangeFilter, (person: PersonRow) => boolean>
+
+const CHANGE_LABEL = {
+  pending: "Pending until linked",
+  sent: "Waiting for Auth",
+  refused: "Refused by Auth",
+} satisfies Record<ChangeFilter, string>
+
 function matchesFilters(person: PersonRow, filters: Filters) {
   if (filters.role && !ROLE_TEST[filters.role](person)) return false
-  if (filters.team && !activeTeams(person).some((team) => team.team === filters.team)) return false
-  if (filters.campus && person.profile.campus !== filters.campus) return false
+  if (filters.team && !currentTeams(person).some((team) => team.team === filters.team)) return false
   if (filters.account && person.account.status !== filters.account) return false
+  if (filters.change && !CHANGE_TEST[filters.change](person)) return false
   return true
 }
 
 function matchesQuery(person: PersonRow, query: string) {
   if (query === "") return true
-  const { profile } = person
-  const haystack = `${personName(person)} ${profile.personalEmail ?? ""} ${profile.telegramUsername ?? ""} ${person.id}`
+  const haystack = `${personName(person)} ${person.contactEmail ?? ""} ${person.telegramUsername ?? ""} ${person.id}`
   return haystack.toLocaleLowerCase().includes(query.replace(/^@/, ""))
 }
 
+/** The most urgent thing about the record's roles: a refusal, then a change waiting for Auth, then a link. */
+function ChangesBadge({ person }: { person: PersonRow }) {
+  const refused = openRefusals(person).length
+  if (refused) return <StatusBadge tone="danger">{refused > 1 ? `${refused} refused` : "Refused by Auth"}</StatusBadge>
+  if (CHANGE_TEST.sent(person)) return <StatusBadge tone="brand">Waiting for Auth</StatusBadge>
+  const pending = person.assignments.filter((a) => a.endedOn === null && a.status === "pending").length
+  if (pending) return <StatusBadge tone="neutral">{`${pluralize(pending, "role")} pending`}</StatusBadge>
+  return null
+}
+
 const columns: DataTableColumn<PersonRow>[] = [
   {
     id: "name",
@@ -85,7 +111,7 @@ const columns: DataTableColumn<PersonRow>[] = [
       const roles = roleLabels(person)
       return (
         <>
-          <PersonCell name={personName(person)} secondary={person.profile.personalEmail} muted={hasNoRoles(person)} />
+          <PersonCell name={personName(person)} secondary={person.contactEmail} muted={hasNoRoles(person)} />
           {/* Mobile cards: one labelled summary line instead of unlabelled column values. */}
           <span className="mt-2 hidden flex-wrap items-center gap-1.5 pl-11 max-shell:flex">
             {roles.length ? (
@@ -94,42 +120,25 @@ const columns: DataTableColumn<PersonRow>[] = [
               <span className="text-xs text-(--pn-fg-muted)">No roles</span>
             )}
             <StateBadge state={ACCOUNT_STATUS[person.account.status]} />
+            <ChangesBadge person={person} />
           </span>
         </>
       )
     },
   },
   {
-    id: "admin",
-    label: "Admin",
-    width: 104,
-    mobile: "hidden",
-    cell: (person) =>
-      person.admin ? (
-        <StateBadge
-          state={
-            person.admin.status === "active"
-              ? { label: "Active", tone: "success" }
-              : { label: "Former", tone: "neutral" }
-          }
-        />
-      ) : (
-        <Unset />
-      ),
-  },
-  {
-    id: "teams",
-    label: "Teams",
-    width: 184,
-    priority: 2,
+    id: "roles",
+    label: "Roles",
+    width: 232,
     mobile: "hidden",
     cell: (person) => {
-      const teams = activeTeams(person)
-      return teams.length ? (
+      const roles = roleLabels(person)
+      return roles.length ? (
         <ChipOverflow
-          items={teams.map((team) => team.team)}
-          itemLabel={teamName}
-          renderItem={(team) => <TruncatedChip key={team} label={teamName(team)} />}
+          items={roles}
+          max={2}
+          itemLabel={(role) => role}
+          renderItem={(role) => <TruncatedChip key={role} label={role} />}
         />
       ) : (
         <Unset />
@@ -137,12 +146,12 @@ const columns: DataTableColumn<PersonRow>[] = [
     },
   },
   {
-    id: "capo",
-    label: "Capo Admin",
-    width: 168,
-    priority: 4,
+    id: "changes",
+    label: "With Auth",
+    width: 176,
+    priority: 3,
     mobile: "hidden",
-    cell: (person) => (person.admin?.capoScope ? <Chip>{person.admin.capoScope}</Chip> : <Unset />),
+    cell: (person) => <ChangesBadge person={person} />,
   },
   {
     id: "account",
@@ -155,9 +164,10 @@ const columns: DataTableColumn<PersonRow>[] = [
 
 const DEFAULT_SORT: TableSort = { column: "name", direction: "asc" }
 
-/** People › Overview: one row per person with their roles and account. */
-export function PeopleOverviewPage({ people }: { people: PersonRow[] }) {
+/** People › Overview: one row per record, with its roles, where they stand with Auth, and its account. */
+export function PeopleOverviewPage({ people, teams }: { people: PersonRow[]; teams: TeamSummary[] }) {
   const canWrite = useCan("people:write")
+  const canLink = useCan("people:link")
   const [query, setQuery] = useState("")
   const deferredQuery = useDeferredValue(query.trim().toLocaleLowerCase())
   const [filters, setFilters] = useState(NO_FILTERS)
@@ -194,13 +204,8 @@ export function PeopleOverviewPage({ people }: { people: PersonRow[] }) {
   }
 
   function openInvite(person: PersonRow) {
-    if (!person.profile.personalEmail) return
-    setAccountAction({
-      kind: "invite",
-      personId: person.id,
-      name: personName(person),
-      email: person.profile.personalEmail,
-    })
+    if (!person.contactEmail) return
+    setAccountAction({ kind: "invite", personId: person.id, name: personName(person), email: person.contactEmail })
     setAccountOpen(true)
   }
 
@@ -236,6 +241,7 @@ export function PeopleOverviewPage({ people }: { people: PersonRow[] }) {
                   onChange={(value) => setFilter("role", value)}
                   options={[
                     { value: "admin", label: "Admin", count: count(ROLE_TEST.admin) },
+                    { value: "capo", label: "Capo Admin", count: count(ROLE_TEST.capo) },
                     { value: "team", label: "Team member", count: count(ROLE_TEST.team) },
                     { value: "none", label: "No roles", count: count(ROLE_TEST.none) },
                   ]}
@@ -247,13 +253,6 @@ export function PeopleOverviewPage({ people }: { people: PersonRow[] }) {
                   onChange={(value) => setFilter("team", value)}
                   options={TEAM_IDS.map((team) => ({ value: team, label: teamName(team) }))}
                 />
-                <FilterMenu<Campus>
-                  label="Campus"
-                  allLabel="All campuses"
-                  value={filters.campus}
-                  onChange={(value) => setFilter("campus", value)}
-                  options={CAMPUSES.map((campus) => ({ value: campus, label: campus }))}
-                />
                 <FilterMenu<AccountStatus>
                   label="Account"
                   allLabel="All accounts"
@@ -265,6 +264,17 @@ export function PeopleOverviewPage({ people }: { people: PersonRow[] }) {
                     count: count((person) => person.account.status === status),
                   }))}
                 />
+                <FilterMenu<ChangeFilter>
+                  label="With Auth"
+                  allLabel="Any state"
+                  value={filters.change}
+                  onChange={(value) => setFilter("change", value)}
+                  options={(["pending", "sent", "refused"] as const).map((change) => ({
+                    value: change,
+                    label: CHANGE_LABEL[change],
+                    count: count(CHANGE_TEST[change]),
+                  }))}
+                />
               </>
             }
             count={
@@ -290,10 +300,10 @@ export function PeopleOverviewPage({ people }: { people: PersonRow[] }) {
             setPage(1)
           }}
           actions={
-            canWrite
+            canWrite || canLink
               ? (person) => (
                   <RowActions>
-                    {person.account.status === "none" && person.profile.personalEmail ? (
+                    {canWrite && person.account.status === "none" && person.contactEmail ? (
                       <IconButton
                         label="Send invite"
                         ariaLabel={`Send invite to ${personName(person)}`}
@@ -307,15 +317,16 @@ export function PeopleOverviewPage({ people }: { people: PersonRow[] }) {
                       keepSlot
                       label={`More actions for ${personName(person)}`}
                       actions={[
-                        person.account.status !== "linked" && {
-                          label: "Link account",
-                          ariaLabel: `Link an account to ${personName(person)}`,
-                          icon: Link2,
-                          onClick: () => {
-                            setLinkTarget(person)
-                            setLinkOpen(true)
+                        canLink &&
+                          person.account.status !== "linked" && {
+                            label: "Link account",
+                            ariaLabel: `Link an account to ${personName(person)}`,
+                            icon: Link2,
+                            onClick: () => {
+                              setLinkTarget(person)
+                              setLinkOpen(true)
+                            },
                           },
-                        },
                       ]}
                     />
                   </RowActions>
@@ -349,7 +360,7 @@ export function PeopleOverviewPage({ people }: { people: PersonRow[] }) {
               <EmptyState
                 icon={UsersRound}
                 title="No people yet"
-                text="People appear here when you add them."
+                text="People appear here when you add them, or when someone gets a People role in PoliNetwork Auth."
                 action={
                   canWrite ? (
                     <Button size="sm" variant="outline" className={buttonMotion} onClick={openAdd}>
@@ -365,18 +376,18 @@ export function PeopleOverviewPage({ people }: { people: PersonRow[] }) {
       </PageContent>
       {canWrite ? (
         <>
-          <PersonDialog key={addKey} open={addOpen} onOpenChange={setAddOpen} />
+          <PersonDialog key={addKey} open={addOpen} onOpenChange={setAddOpen} teams={teams} />
           <AccountActionDialog action={accountAction} open={accountOpen} onOpenChange={setAccountOpen} />
-          {linkTarget ? (
-            <LinkAccountDialog
-              key={`${linkTarget.id}-${linkKey}`}
-              open={linkOpen}
-              onOpenChange={setLinkOpen}
-              person={{ id: linkTarget.id, name: personName(linkTarget), firstName: linkTarget.profile.firstName }}
-            />
-          ) : null}
         </>
       ) : null}
+      {canLink && linkTarget ? (
+        <LinkAccountDialog
+          key={`${linkTarget.id}-${linkKey}`}
+          open={linkOpen}
+          onOpenChange={setLinkOpen}
+          person={{ id: linkTarget.id, name: personName(linkTarget), firstName: linkTarget.firstName }}
+        />
+      ) : null}
     </>
   )
 }
diff --git a/src/features/people/people-appoint.functions.ts b/src/features/people/people-appoint.functions.ts
index 6d980f5..c0bea34 100644
--- a/src/features/people/people-appoint.functions.ts
+++ b/src/features/people/people-appoint.functions.ts
@@ -3,10 +3,22 @@ import { createServerFn } from "@tanstack/react-start"
 import { peopleAppointMiddleware } from "@/server/auth.middleware"
 
 import { peopleApi } from "./people.api.server"
-import { capoScopeInputSchema } from "./people.contract"
+import { appointCapoInputSchema, capoScopeInputSchema, endAssignmentInputSchema } from "./people.contract"
 
-/** Appoints a Capo Admin of a scope, changes it, or ends the role (`scope: null`). Direttivo only. */
+/** Appoints a current admin Capo Admin of a scope. */
+export const appointCapo = createServerFn({ method: "POST" })
+  .middleware([peopleAppointMiddleware])
+  .validator(appointCapoInputSchema)
+  .handler(async ({ data, context }) => (await peopleApi(context)).appointCapo(data))
+
+/** Changes a Capo Admin's scope: People's own data, nothing changes in Auth. */
 export const setCapoScope = createServerFn({ method: "POST" })
   .middleware([peopleAppointMiddleware])
   .validator(capoScopeInputSchema)
   .handler(async ({ data, context }) => (await peopleApi(context)).setCapoScope(data))
+
+/** Ends the Capo Admin role; they stay an admin, and their admins have no Capo Admin of reference until one is set. */
+export const endCapo = createServerFn({ method: "POST" })
+  .middleware([peopleAppointMiddleware])
+  .validator(endAssignmentInputSchema)
+  .handler(async ({ data, context }) => (await peopleApi(context)).endCapo(data))
diff --git a/src/features/people/people-format.ts b/src/features/people/people-format.ts
index e54cd1e..fa90650 100644
--- a/src/features/people/people-format.ts
+++ b/src/features/people/people-format.ts
@@ -1,43 +1,121 @@
 import type { StatusTone } from "@/components/primitives"
-import { dateOnlyValue } from "@/lib/date-only"
 import { formatDate } from "@/lib/format"
 
-import { type AccountStatus, type PersonRow, type PhotoConsent, TEAMS, type TeamId, YEARS } from "./people.contract"
+import {
+  type AccountStatus,
+  type Assignment,
+  type PersonLike,
+  type PersonRow,
+  TEAMS,
+  type TeamId,
+} from "./people.contract"
+
+export function personName(person: { firstName: string; lastName: string }) {
+  return `${person.firstName} ${person.lastName}`
+}
+
+/**
+ * The assignments in force, as the backend counts them: not ended. An ending Auth hasn't confirmed yet already counts
+ * as ended; `openAssignments` keeps it on screen.
+ */
+export function currentAssignments(person: Pick<PersonLike, "assignments">) {
+  return person.assignments.filter((assignment) => assignment.endedOn === null)
+}
 
-export function personName(person: { profile: { firstName: string; lastName: string } }) {
-  return `${person.profile.firstName} ${person.profile.lastName}`
+export function currentAdmin(person: Pick<PersonLike, "assignments">) {
+  return currentAssignments(person).find((assignment) => assignment.kind === "admin") ?? null
 }
 
-export function isActiveAdmin(person: Pick<PersonRow, "admin">) {
-  return person.admin?.status === "active"
+export function currentCapo(person: Pick<PersonLike, "assignments">) {
+  return currentAssignments(person).find((assignment) => assignment.kind === "capo") ?? null
 }
 
-export function activeTeams(person: Pick<PersonRow, "teams">) {
-  return person.teams.filter((team) => !team.endedOn)
+/** Current team assignments: `team` and `teamRole` are always set on them. */
+export function currentTeams(person: Pick<PersonLike, "assignments">) {
+  return currentAssignments(person).filter(
+    (assignment): assignment is TeamAssignment => assignment.kind === "team" && assignment.team !== null
+  )
+}
+
+export type TeamAssignment = Assignment & { kind: "team"; team: TeamId; teamRole: "member" | "lead" }
+
+export function isTeamAssignment(assignment: Assignment): assignment is TeamAssignment {
+  return assignment.kind === "team" && assignment.team !== null && assignment.teamRole !== null
 }
 
-/** No active Admin or Team role: the record stays for history and shows muted. */
-export function hasNoRoles(person: Pick<PersonRow, "admin" | "teams">) {
-  return !isActiveAdmin(person) && activeTeams(person).length === 0
+/** What a record's Roles card shows: the current assignments, and the changes still waiting for or refused by Auth. */
+export function openAssignments(person: Pick<PersonLike, "assignments">) {
+  const refused = new Set(openRefusals(person))
+  return person.assignments.filter(
+    (assignment) => assignment.endedOn === null || assignment.status === "sent" || refused.has(assignment)
+  )
 }
 
-/** A stored year as one of the form's options; unknown values fall back to the first year. */
-export function yearOf(value: string): (typeof YEARS)[number] {
-  return YEARS.find((year) => year === value) ?? "1st year"
+/** No current role: the record stays for history and shows muted. */
+export function hasNoRoles(person: Pick<PersonLike, "assignments">) {
+  return currentAssignments(person).length === 0
+}
+
+/** What an assignment is about, for grouping its history: "admin", "capo" or "team:it". */
+export function conceptOf(assignment: Assignment) {
+  return assignment.kind === "team" ? `team:${assignment.team}` : assignment.kind
+}
+
+/**
+ * Refusals someone has to act on: Auth refused a start (the assignment ended) and nobody has assigned it again, or it
+ * refused an end (the role is still held).
+ */
+export function openRefusals(person: Pick<PersonLike, "assignments">) {
+  const current = new Set(currentAssignments(person).map(conceptOf))
+  return person.assignments.filter(
+    (assignment) =>
+      assignment.status === "refused" &&
+      (assignment.endedOn === null || (assignment.change === "start" && !current.has(conceptOf(assignment))))
+  )
 }
 
 export function teamName(team: TeamId) {
   return TEAMS[team].name
 }
 
-/** "Admin", "IT · Lead", "Capo Admin · Design". */
-export function roleLabels(person: Pick<PersonRow, "admin" | "teams">) {
-  const labels: string[] = []
-  if (isActiveAdmin(person)) labels.push("Admin")
-  for (const team of activeTeams(person))
-    labels.push(team.role === "lead" ? `${teamName(team.team)} · Lead` : teamName(team.team))
-  if (person.admin?.capoScope) labels.push(`Capo Admin · ${person.admin.capoScope}`)
-  return labels
+/** "Admin", "Capo Admin · Informatica", "IT · Lead", "HR". */
+export function assignmentLabel(assignment: Assignment) {
+  if (assignment.kind === "admin") return "Admin"
+  if (assignment.kind === "capo") return assignment.capoScope ? `Capo Admin · ${assignment.capoScope}` : "Capo Admin"
+  if (!assignment.team) return "Team"
+  return assignment.teamRole === "lead" ? `${teamName(assignment.team)} · Lead` : teamName(assignment.team)
+}
+
+/** The current roles as labels, admin first. */
+export function roleLabels(person: Pick<PersonLike, "assignments">) {
+  const order = { admin: 0, capo: 1, team: 2 }
+  return currentAssignments(person)
+    .toSorted((a, b) => order[a.kind] - order[b.kind])
+    .map(assignmentLabel)
+}
+
+type Tone = { label: string; tone: StatusTone }
+
+/**
+ * Where an assignment stands with PoliNetwork Auth. `applied` needs no badge on a current assignment, so callers may
+ * skip it; the rest always show.
+ */
+export function assignmentState(assignment: Pick<Assignment, "status" | "change">): Tone {
+  switch (assignment.status) {
+    case "pending":
+      return { label: "Pending until linked", tone: "neutral" }
+    case "sent":
+      return { label: assignment.change === "end" ? "Ending · waiting for Auth" : "Waiting for Auth", tone: "brand" }
+    case "refused":
+      return { label: "Refused by Auth", tone: "danger" }
+    case "applied":
+      return { label: "Applied", tone: "success" }
+  }
+}
+
+/** Whether a role change on this record waits for Auth: the backend refuses another one until Auth answers. */
+export function waitingForAuth(person: Pick<PersonLike, "assignments" | "account">) {
+  return person.account.status === "linked" && person.assignments.some((assignment) => assignment.status === "sent")
 }
 
 /** "6 Oct 2026" for an ISO date (`YYYY-MM-DD`) or timestamp. */
@@ -45,28 +123,40 @@ export function formatDay(value: string) {
   return formatDate(new Date(value.length === 10 ? `${value}T12:00:00Z` : value))
 }
 
-/** Today in the browser's timezone, as an ISO date: date inputs start from it. */
+/**
+ * Today in Europe/Rome as an ISO date, the calendar the backend checks start dates against ("in the future" is later
+ * than this): date inputs and the roles Add person starts with use it.
+ */
 export function todayIso() {
-  return dateOnlyValue(new Date())
+  return new Intl.DateTimeFormat("en-CA", { timeZone: "Europe/Rome" }).format(new Date())
 }
 
 export function isExpired(date: string) {
   return date < todayIso()
 }
 
-type Tone = { label: string; tone: StatusTone }
-
 export const ACCOUNT_STATUS = {
   none: { label: "Not linked", tone: "neutral" },
   invite: { label: "Invite sent", tone: "brand" },
   linked: { label: "Linked", tone: "success" },
 } satisfies Record<AccountStatus, Tone>
 
-export const PHOTO_CONSENT = {
-  granted: { label: "Granted", tone: "success" },
-  denied: { label: "Denied", tone: "neutral" },
-  revoked: { label: "Revoked", tone: "neutral" },
-} satisfies Record<PhotoConsent, Tone>
+export const LINK_METHOD = {
+  invite: "Email invite",
+  manual: "Linked by hand",
+  auth: "Role given in PoliNetwork Auth",
+} as const
+
+/**
+ * Who did something, from the account ID the backend records: the name of the person linked to it when the page has
+ * the records, otherwise the ID itself. `auth` and `system` are the backend's own actors.
+ */
+export function actorName(actor: string, people: readonly Pick<PersonRow, "firstName" | "lastName" | "account">[]) {
+  if (actor === "auth") return "PoliNetwork Auth"
+  if (actor === "system") return "System"
+  const person = people.find((candidate) => candidate.account.status === "linked" && candidate.account.sub === actor)
+  return person ? personName(person) : actor
+}
 
 export function telegramUrl(username: string) {
   return `https://t.me/${username.replace(/^@/, "")}`
diff --git a/src/features/people/people-hooks.ts b/src/features/people/people-hooks.ts
index 1f6e71b..6b15b8d 100644
--- a/src/features/people/people-hooks.ts
+++ b/src/features/people/people-hooks.ts
@@ -23,6 +23,18 @@ export function useRefreshAfter() {
   }
 }
 
+/**
+ * After a failed role change: when PoliNetwork Auth refuses, the backend records the refusal (a refused start ends the
+ * assignment) before it answers with Auth's words, so the page behind the dialog reloads to show it. It doesn't wait:
+ * the dialog shows the error meanwhile.
+ */
+export function useReloadAfterFailure() {
+  const router = useRouter()
+  return () => {
+    router.invalidate().catch((error) => console.error(error))
+  }
+}
+
 /** The message to show for a failed call: the backend's own words, or the fallback (also for a bare UNAUTHORIZED). */
 export function errorMessage(cause: unknown, fallback: string) {
   const message = backendMessage(cause, fallback)
diff --git a/src/features/people/people-invites.functions.ts b/src/features/people/people-invites.functions.ts
new file mode 100644
index 0000000..8aab0c2
--- /dev/null
+++ b/src/features/people/people-invites.functions.ts
@@ -0,0 +1,20 @@
+import { createServerFn } from "@tanstack/react-start"
+
+import { peopleTeamWriteMiddleware } from "@/server/auth.middleware"
+
+import { peopleApi } from "./people.api.server"
+import { personRefInputSchema } from "./people.contract"
+
+/**
+ * Sends an invite to the record's contact email, or a new one replacing the open invite (its link stops working).
+ * `people:write`, or the Lead of one of the person's teams: the backend decides.
+ */
+export const sendPersonInvite = createServerFn({ method: "POST" })
+  .middleware([peopleTeamWriteMiddleware])
+  .validator(personRefInputSchema)
+  .handler(async ({ data, context }) => (await peopleApi(context)).sendInvite(data))
+
+export const revokePersonInvite = createServerFn({ method: "POST" })
+  .middleware([peopleTeamWriteMiddleware])
+  .validator(personRefInputSchema)
+  .handler(async ({ data, context }) => (await peopleApi(context)).revokeInvite(data))
diff --git a/src/features/people/people-link.functions.ts b/src/features/people/people-link.functions.ts
new file mode 100644
index 0000000..71a15ea
--- /dev/null
+++ b/src/features/people/people-link.functions.ts
@@ -0,0 +1,24 @@
+import { createServerFn } from "@tanstack/react-start"
+
+import { peopleLinkMiddleware } from "@/server/auth.middleware"
+
+import { peopleApi } from "./people.api.server"
+import { linkAccountInputSchema, searchAccountsInputSchema, unlinkAccountInputSchema } from "./people.contract"
+
+/** Sign-in accounts in the IdP directory, with the record each is linked to. */
+export const searchPeopleAccounts = createServerFn({ method: "GET" })
+  .middleware([peopleLinkMiddleware])
+  .validator(searchAccountsInputSchema)
+  .handler(async ({ data, context }) => (await peopleApi(context)).searchAccounts(data))
+
+/** Links by hand: the record's pending assignments go to Auth, acting as whoever links. */
+export const linkPersonAccount = createServerFn({ method: "POST" })
+  .middleware([peopleLinkMiddleware])
+  .validator(linkAccountInputSchema)
+  .handler(async ({ data, context }) => (await peopleApi(context)).linkAccount(data))
+
+/** Auth takes the record's roles back, then the account is detached; the assignments wait as pending. */
+export const unlinkPersonAccount = createServerFn({ method: "POST" })
+  .middleware([peopleLinkMiddleware])
+  .validator(unlinkAccountInputSchema)
+  .handler(async ({ data, context }) => (await peopleApi(context)).unlinkAccount(data))
diff --git a/src/features/people/people-self.functions.ts b/src/features/people/people-self.functions.ts
index e40bddb..988d71e 100644
--- a/src/features/people/people-self.functions.ts
+++ b/src/features/people/people-self.functions.ts
@@ -3,7 +3,7 @@ import { createServerFn } from "@tanstack/react-start"
 import { peopleSelfMiddleware } from "@/server/auth.middleware"
 
 import { peopleApi } from "./people.api.server"
-import { acceptInviteInputSchema } from "./people.contract"
+import { inviteTokenInputSchema } from "./people.contract"
 
 /** Account › My area: the signed-in person's record, or nothing yet. */
 export const getMyArea = createServerFn({ method: "GET" })
@@ -13,5 +13,5 @@ export const getMyArea = createServerFn({ method: "GET" })
 /** The invite link HR emails: links the signed-in account to the invited record. */
 export const acceptMyInvite = createServerFn({ method: "POST" })
   .middleware([peopleSelfMiddleware])
-  .validator(acceptInviteInputSchema)
+  .validator(inviteTokenInputSchema)
   .handler(async ({ data, context }) => (await peopleApi(context)).acceptInvite(data))
diff --git a/src/features/people/people-teams.functions.ts b/src/features/people/people-teams.functions.ts
index 366b727..c59b911 100644
--- a/src/features/people/people-teams.functions.ts
+++ b/src/features/people/people-teams.functions.ts
@@ -15,7 +15,7 @@ export const getTeams = createServerFn({ method: "GET" })
   .middleware([peopleTeamReadMiddleware])
   .handler(async ({ context }) => (await peopleApi(context)).listTeams())
 
-/** Names and courses of the people who could join a team; Team Leads see no more than that. */
+/** Names of the people who could join a team; Team Leads see no more than that. */
 export const getTeamCandidates = createServerFn({ method: "GET" })
   .middleware([peopleTeamReadMiddleware])
   .validator(teamCandidatesInputSchema)
diff --git a/src/features/people/people-ui.tsx b/src/features/people/people-ui.tsx
index 40c7e62..e08f22f 100644
--- a/src/features/people/people-ui.tsx
+++ b/src/features/people/people-ui.tsx
@@ -23,6 +23,9 @@ import {
 import { Hint } from "@/components/primitives/hint"
 import { cn } from "@/lib/utils"
 
+import { assignmentState } from "./people-format"
+import type { Assignment } from "./people.contract"
+
 /** 32px initials avatar, name and an optional 12px secondary line; muted when the person has no roles left. */
 export function PersonCell({
   name,
@@ -97,7 +100,28 @@ export function StateBadge({ state }: { state: { label: string; tone: StatusTone
   return <StatusBadge tone={state.tone}>{state.label}</StatusBadge>
 }
 
-/** Identifiers (member numbers, person IDs) as a mono chip. */
+/**
+ * Where an assignment stands with PoliNetwork Auth. Applied ones show nothing unless `showApplied`: on a current role
+ * it is the normal state.
+ */
+export function AssignmentBadge({
+  assignment,
+  showApplied = false,
+}: {
+  assignment: Pick<Assignment, "status" | "change">
+  showApplied?: boolean
+}) {
+  if (assignment.status === "applied" && !showApplied) return null
+  return <StateBadge state={assignmentState(assignment)} />
+}
+
+/** Auth's refusal, word for word. */
+export function RefusalText({ refusal }: { refusal: string | null }) {
+  if (!refusal) return null
+  return <span className="text-[13px] text-(--pn-danger-fg) [overflow-wrap:anywhere]">{refusal}</span>
+}
+
+/** Identifiers (account IDs, person IDs) as a mono chip. */
 export function MonoChip({ children }: { children: ReactNode }) {
   return <Chip className="font-mono tabular-nums">{children}</Chip>
 }
@@ -124,14 +148,14 @@ export function ActionMenu({
   /** The ⋮ button's accessible name ("More actions for Giulia Rossi"). */
   label: string
   actions: readonly (MenuAction | false)[]
-  /** In tables: an empty 36px slot when no action applies, so the icons of every row stay aligned. */
+  /** In tables: an empty 36px slot when no action applies, so every row's icons stay aligned (not on mobile cards). */
   keepSlot?: boolean
 }) {
   const available = actions.filter((action) => action !== false)
   const regular = available.filter((action) => !action.destructive)
   const destructive = available.filter((action) => action.destructive)
   const [only] = available
-  if (!only) return keepSlot ? <span aria-hidden className="size-9 shrink-0" /> : null
+  if (!only) return keepSlot ? <span aria-hidden className="size-9 shrink-0 max-shell:hidden" /> : null
   if (available.length === 1) {
     return <IconButton label={only.label} ariaLabel={only.ariaLabel} icon={only.icon} onClick={only.onClick} />
   }
diff --git a/src/features/people/people-write.functions.ts b/src/features/people/people-write.functions.ts
index a587091..97bb04b 100644
--- a/src/features/people/people-write.functions.ts
+++ b/src/features/people/people-write.functions.ts
@@ -1,22 +1,56 @@
 import { createServerFn } from "@tanstack/react-start"
 
+import { errorMessage } from "@/lib/errors"
 import { peopleWriteMiddleware } from "@/server/auth.middleware"
 
+import { todayIso } from "./people-format"
 import { peopleApi } from "./people.api.server"
 import {
+  assignAdminInputSchema,
   capoRefInputSchema,
-  createPersonInputSchema,
-  endAdminInputSchema,
-  linkAccountInputSchema,
-  personRefInputSchema,
+  endAssignmentInputSchema,
+  type NewPersonResult,
+  newPersonInputSchema,
   setNoteInputSchema,
+  TEAMS,
   updatePersonInputSchema,
 } from "./people.contract"
 
+/**
+ * Creates the record, then starts each role it was given, from today in Europe/Rome (the backend's calendar for start
+ * dates, whatever the server's timezone). A role the backend refuses (no clearance, no role bound in Auth) doesn't
+ * undo the record: the result lists it, with the backend's words, so the page can say so.
+ */
 export const createPerson = createServerFn({ method: "POST" })
   .middleware([peopleWriteMiddleware])
-  .validator(createPersonInputSchema)
-  .handler(async ({ data, context }) => (await peopleApi(context)).createPerson(data))
+  .validator(newPersonInputSchema)
+  .handler(async ({ data, context }): Promise<NewPersonResult> => {
+    const api = await peopleApi(context)
+    const { admin, capoScope, teams, ...fields } = data
+    const { id } = await api.createPerson(fields)
+    const since = todayIso()
+    const refused: NewPersonResult["refused"] = []
+    const attempt = async (role: string, start: () => Promise<void>) => {
+      try {
+        await start()
+        return true
+      } catch (error) {
+        console.error(error)
+        refused.push({ role, message: errorMessage(error, "Refused.") })
+        return false
+      }
+    }
+    const isAdmin = admin && (await attempt("Admin", () => api.assignAdmin({ personId: id, since, capoId: null })))
+    if (capoScope !== null) {
+      if (isAdmin) await attempt("Capo Admin", () => api.appointCapo({ personId: id, since, scope: capoScope }))
+      else refused.push({ role: "Capo Admin", message: "A Capo Admin must be an admin first." })
+    }
+    for (const { team, role } of teams)
+      await attempt(`${TEAMS[team].name}${role === "lead" ? " Lead" : ""}`, () =>
+        api.addTeamMember({ teamId: team, personId: id, role, since, fields: {} })
+      )
+    return { id, refused }
+  })
 
 export const updatePerson = createServerFn({ method: "POST" })
   .middleware([peopleWriteMiddleware])
@@ -28,31 +62,15 @@ export const setPersonNote = createServerFn({ method: "POST" })
   .validator(setNoteInputSchema)
   .handler(async ({ data, context }) => (await peopleApi(context)).setNote(data))
 
-/** Sends an invite, or a new one replacing the pending invite (its link stops working). */
-export const sendPersonInvite = createServerFn({ method: "POST" })
+/** Pending until the record is linked; for a linked record, sent to PoliNetwork Auth, which may refuse it. */
+export const assignAdmin = createServerFn({ method: "POST" })
   .middleware([peopleWriteMiddleware])
-  .validator(personRefInputSchema)
-  .handler(async ({ data, context }) => (await peopleApi(context)).sendInvite(data))
+  .validator(assignAdminInputSchema)
+  .handler(async ({ data, context }) => (await peopleApi(context)).assignAdmin(data))
 
-export const revokePersonInvite = createServerFn({ method: "POST" })
-  .middleware([peopleWriteMiddleware])
-  .validator(personRefInputSchema)
-  .handler(async ({ data, context }) => (await peopleApi(context)).revokeInvite(data))
-
-export const linkPersonAccount = createServerFn({ method: "POST" })
-  .middleware([peopleWriteMiddleware])
-  .validator(linkAccountInputSchema)
-  .handler(async ({ data, context }) => (await peopleApi(context)).linkAccount(data))
-
-export const unlinkPersonAccount = createServerFn({ method: "POST" })
-  .middleware([peopleWriteMiddleware])
-  .validator(personRefInputSchema)
-  .handler(async ({ data, context }) => (await peopleApi(context)).unlinkAccount(data))
-
-/** The bot removes their admin rights in every group; the record keeps the history. */
 export const endAdminRole = createServerFn({ method: "POST" })
   .middleware([peopleWriteMiddleware])
-  .validator(endAdminInputSchema)
+  .validator(endAssignmentInputSchema)
   .handler(async ({ data, context }) => (await peopleApi(context)).endAdmin(data))
 
 export const setCapoOfReference = createServerFn({ method: "POST" })
diff --git a/src/features/people/people.api.server.ts b/src/features/people/people.api.server.ts
index 0523d47..4d0fe4c 100644
--- a/src/features/people/people.api.server.ts
+++ b/src/features/people/people.api.server.ts
@@ -3,19 +3,26 @@ import type { z } from "zod"
 import { createUntypedBackendClient } from "@/server/backend.server"
 
 import {
-  type AcceptInviteInput,
-  type AddTeamMemberInput,
-  accountMatchSchema,
   type AccountMatch,
+  accountMatchSchema,
+  type AddTeamMemberInput,
+  type AdminSummary,
+  adminSummarySchema,
+  type AppointCapoInput,
+  type AssignAdminInput,
   type CapoArea,
   capoAreaSchema,
   type CapoRefInput,
   type CapoScopeInput,
+  type CapoSummary,
+  capoSummarySchema,
   type CreatePersonInput,
   createdSchema,
-  type EndAdminInput,
+  type EndAssignmentInput,
   type EndTeamInput,
   type Invite,
+  type InvitePreview,
+  invitePreviewSchema,
   inviteSchema,
   type LinkAccountInput,
   type MyArea,
@@ -26,6 +33,8 @@ import {
   personRecordSchema,
   type PersonRow,
   personRowSchema,
+  type RecentLink,
+  recentLinkSchema,
   type SearchAccountsInput,
   type SetNoteInput,
   type TeamCandidate,
@@ -34,12 +43,16 @@ import {
   type TeamFieldsInput,
   type TeamSummary,
   teamSummarySchema,
+  type UnlinkAccountInput,
   type UpdatePersonInput,
 } from "./people.contract"
 
 /** Who is asking: their permissions, and their own record in agent mode (`AGENT_PERSON`). */
 export type PeopleViewer = { permissions: readonly string[]; personId: string | null }
 
+type PersonRef = { personId: string }
+type Token = { token: string }
+
 /** The `people.*` procedures (docs/people/contract.md), one method each. */
 export type PeopleApi = {
   listPeople: () => Promise<PersonRow[]>
@@ -47,29 +60,36 @@ export type PeopleApi = {
   createPerson: (input: CreatePersonInput) => Promise<{ id: string }>
   updatePerson: (input: UpdatePersonInput) => Promise<void>
   setNote: (input: SetNoteInput) => Promise<void>
-  endAdmin: (input: EndAdminInput) => Promise<void>
-  setCapoScope: (input: CapoScopeInput) => Promise<void>
+  listAdmins: () => Promise<AdminSummary[]>
+  assignAdmin: (input: AssignAdminInput) => Promise<void>
+  endAdmin: (input: EndAssignmentInput) => Promise<void>
   setCapoOfReference: (input: CapoRefInput) => Promise<void>
+  listCapos: () => Promise<CapoSummary[]>
+  appointCapo: (input: AppointCapoInput) => Promise<void>
+  setCapoScope: (input: CapoScopeInput) => Promise<void>
+  endCapo: (input: EndAssignmentInput) => Promise<void>
   listTeams: () => Promise<TeamSummary[]>
   listTeamCandidates: (input: TeamCandidatesInput) => Promise<TeamCandidate[]>
   addTeamMember: (input: AddTeamMemberInput) => Promise<void>
   updateTeamFields: (input: TeamFieldsInput) => Promise<void>
   endTeamMembership: (input: EndTeamInput) => Promise<void>
   listInvites: () => Promise<Invite[]>
-  sendInvite: (input: { personId: string }) => Promise<void>
-  revokeInvite: (input: { personId: string }) => Promise<void>
+  listRecentLinks: () => Promise<RecentLink[]>
+  sendInvite: (input: PersonRef) => Promise<void>
+  revokeInvite: (input: PersonRef) => Promise<void>
   searchAccounts: (input: SearchAccountsInput) => Promise<AccountMatch[]>
   linkAccount: (input: LinkAccountInput) => Promise<void>
-  unlinkAccount: (input: { personId: string }) => Promise<void>
+  unlinkAccount: (input: UnlinkAccountInput) => Promise<void>
   getCapoArea: () => Promise<CapoArea>
   getMyRoles: () => Promise<MyRoles>
   getMyArea: () => Promise<MyArea>
-  acceptInvite: (input: AcceptInviteInput) => Promise<void>
+  previewInvite: (input: Token) => Promise<InvitePreview>
+  acceptInvite: (input: Token) => Promise<void>
 }
 
 /**
- * The backend's `people.*` procedures. The published router type doesn't declare them yet, so every response is
- * parsed with the contract's schema: a backend that drifts from the contract fails loudly here, not in a page.
+ * The backend's `people.*` procedures. Every response is parsed with the contract's schema: a backend that drifts
+ * from the contract fails loudly here, not in a page.
  */
 function backendPeopleApi(accessToken: string | null): PeopleApi {
   const client = createUntypedBackendClient(accessToken)
@@ -87,15 +107,21 @@ function backendPeopleApi(accessToken: string | null): PeopleApi {
     createPerson: (input) => mutateParsed("persons.create", input, createdSchema),
     updatePerson: (input) => mutate("persons.update", input),
     setNote: (input) => mutate("persons.setNote", input),
+    listAdmins: () => query("admins.list", undefined, adminSummarySchema.array()),
+    assignAdmin: (input) => mutate("admins.assign", input),
     endAdmin: (input) => mutate("admins.end", input),
-    setCapoScope: (input) => mutate("admins.setCapoScope", input),
     setCapoOfReference: (input) => mutate("admins.setCapoOfReference", input),
+    listCapos: () => query("capos.list", undefined, capoSummarySchema.array()),
+    appointCapo: (input) => mutate("capos.appoint", input),
+    setCapoScope: (input) => mutate("capos.setScope", input),
+    endCapo: (input) => mutate("capos.end", input),
     listTeams: () => query("teams.list", undefined, teamSummarySchema.array()),
     listTeamCandidates: (input) => query("teams.candidates", input, teamCandidateSchema.array()),
     addTeamMember: (input) => mutate("teams.addMember", input),
     updateTeamFields: (input) => mutate("teams.updateFields", input),
     endTeamMembership: (input) => mutate("teams.endMembership", input),
     listInvites: () => query("linking.invites", undefined, inviteSchema.array()),
+    listRecentLinks: () => query("linking.recent", undefined, recentLinkSchema.array()),
     sendInvite: (input) => mutate("linking.sendInvite", input),
     revokeInvite: (input) => mutate("linking.revokeInvite", input),
     searchAccounts: (input) => query("linking.searchAccounts", input, accountMatchSchema.array()),
@@ -104,6 +130,7 @@ function backendPeopleApi(accessToken: string | null): PeopleApi {
     getCapoArea: () => query("capo.get", undefined, capoAreaSchema),
     getMyRoles: () => query("me.roles", undefined, myRolesSchema),
     getMyArea: () => query("me.get", undefined, myAreaSchema),
+    previewInvite: (input) => query("me.invite", input, invitePreviewSchema),
     acceptInvite: (input) => mutate("me.acceptInvite", input),
   }
 }
diff --git a/src/features/people/people.contract.ts b/src/features/people/people.contract.ts
index af2980f..0a4f710 100644
--- a/src/features/people/people.contract.ts
+++ b/src/features/people/people.contract.ts
@@ -1,77 +1,40 @@
 import { z } from "zod"
 
 /**
- * The `people.*` backend contract (docs/people/contract.md), served by the backend's `src/people/router.ts`. Agent mode
- * answers from `people.fake.server.ts`; real responses are parsed with these schemas before they reach a page.
+ * The `people.*` backend contract (docs/people/contract.md), a copy of the backend's `src/people/contract.ts` (Phase 1,
+ * PoliNetworkOrg/backend#105 and #106). Agent mode answers from `people.fake.server.ts`; real responses are parsed with
+ * these schemas before they reach a page. Keep both copies in step.
  *
- * Soci, fees, receipts, the census and record matching are no longer part of it (#138): their pages are unconnected
- * mockups with their own sample data (`mockup-data.ts`). Until the backend drops them too, it still sends fields such as
- * `member`, `isMember`, `census`, `fees`, `admin.groups` and contact emails: `z.object` strips unknown keys, so they are
- * ignored.
+ * A person is a record with a name and contacts; their roles are assignments (Group Admin, Capo Admin, member or Lead
+ * of a team). While the record isn't linked to a sign-in account they wait as `pending`; once linked, PoliNetwork Auth
+ * holds them as RBAC roles and has the last word.
+ *
+ * Soci, fees, receipts and the census are not part of it (#138): their pages are unconnected mockups with their own
+ * sample data (`mockup-data.ts`).
  */
 
+/**
+ * The teams People knows. A team can only be assigned once PoliNetwork Auth binds a role to it
+ * (`team:<id>:member` / `team:<id>:lead`); see `TeamSummary.assignable`.
+ */
 export const TEAM_IDS = ["it", "hr", "design", "intl", "events"] as const
-export const CAMPUSES = ["Leonardo", "Bovisa", "Cremona", "Piacenza", "Mantova", "Lecco", "External"] as const
-export const YEARS = ["1st year", "2nd year", "3rd year", "1st year MSc", "2nd year MSc", "Graduated"] as const
-/** Politecnico di Milano courses offered in forms; the backend accepts any course name. */
-export const COURSES = [
-  "Ingegneria Informatica",
-  "Computer Science and Engineering",
-  "Ingegneria Gestionale",
-  "Management Engineering",
-  "Ingegneria Meccanica",
-  "Ingegneria Aerospaziale",
-  "Ingegneria Energetica",
-  "Ingegneria Chimica",
-  "Ingegneria Elettronica",
-  "Ingegneria Biomedica",
-  "Ingegneria Matematica",
-  "Ingegneria Civile",
-  "Design della Comunicazione",
-  "Design del Prodotto Industriale",
-  "Design degli Interni",
-  "Architettura",
-  "Urbanistica",
-] as const
-export const ACCOUNT_STATUSES = ["none", "invite", "linked"] as const
-export const PHOTO_CONSENTS = ["granted", "denied", "revoked"] as const
 
 export const teamIdSchema = z.enum(TEAM_IDS)
-export const campusSchema = z.enum(CAMPUSES)
-
 export type TeamId = z.infer<typeof teamIdSchema>
-export type Campus = z.infer<typeof campusSchema>
-export type AccountStatus = (typeof ACCOUNT_STATUSES)[number]
-export type PhotoConsent = (typeof PHOTO_CONSENTS)[number]
 
 const personRefSchema = z.object({ id: z.string(), name: z.string() })
+export type PersonRef = z.infer<typeof personRefSchema>
 
-export const profileSchema = z.object({
-  firstName: z.string(),
-  lastName: z.string(),
-  /** `null` without contact rights. */
-  personalEmail: z.string().nullable(),
-  /** `null` without contact rights. */
-  phone: z.string().nullable(),
-  telegramUsername: z.string().nullable(),
-  telegramId: z.string().nullable(),
-  course: z.string(),
-  year: z.string(),
-  campus: campusSchema,
-  otherAssociations: z.array(z.string()),
-  studentRepresentative: z.string().nullable(),
-})
-
-export const adminRoleSchema = z.object({
-  status: z.enum(["active", "former"]),
-  since: z.string(),
-  endedOn: z.string().nullable(),
-  endReason: z.string().nullable(),
-  availableAsCapo: z.boolean(),
-  capoOfReference: personRefSchema.nullable(),
-  /** Set when this person is a Capo Admin, e.g. "Ingegneria Informatica". */
-  capoScope: z.string().nullable(),
-})
+export const ASSIGNMENT_KINDS = ["admin", "capo", "team"] as const
+export const TEAM_ROLES = ["member", "lead"] as const
+/**
+ * Where an assignment stands with PoliNetwork Auth:
+ * - `pending`: the record is not linked to a login account, so Auth knows nothing of it yet;
+ * - `sent`: the change was sent to Auth, which has not confirmed it yet;
+ * - `applied`: Auth holds it (or, for an ending, no longer holds it);
+ * - `refused`: Auth refused the change; `refusal` says why.
+ */
+export const ASSIGNMENT_STATUSES = ["pending", "sent", "applied", "refused"] as const
 
 export const teamFieldsSchema = z.record(z.string(), z.union([z.string(), z.array(z.string())]))
 /** The team-specific fields a dashboard write may send: a handful of short keys and values. */
@@ -79,14 +42,33 @@ const teamFieldsInput = z
   .record(z.string().min(1).max(40), z.union([z.string().trim().max(200), z.array(z.string().trim().max(60)).max(20)]))
   .refine((fields) => Object.keys(fields).length <= 10, "Too many fields.")
 
-export const teamMembershipSchema = z.object({
-  team: teamIdSchema,
-  role: z.enum(["member", "lead"]),
+/** Group Admin, Capo Admin, or member or Lead of a team. */
+export const assignmentSchema = z.object({
+  id: z.string(),
+  kind: z.enum(ASSIGNMENT_KINDS),
+  /** Set for `team`. */
+  team: teamIdSchema.nullable(),
+  /** Set for `team`. */
+  teamRole: z.enum(TEAM_ROLES).nullable(),
+  /** Set for `capo`, e.g. "Ingegneria Informatica". */
+  capoScope: z.string().nullable(),
+  /** Set for `admin`: the Capo Admin this admin answers to. */
+  capoOfReference: personRefSchema.nullable(),
+  /** Team-specific fields, for `team`. */
+  fields: teamFieldsSchema,
   since: z.string(),
+  /** `null` while current. */
   endedOn: z.string().nullable(),
   endReason: z.string().nullable(),
-  fields: teamFieldsSchema,
+  /** The account that made the assignment, or `auth` when it was made by hand in PoliNetwork Auth. */
+  assignedBy: z.string(),
+  /** Whether `status` is about starting or ending it. */
+  change: z.enum(["start", "end"]),
+  status: z.enum(ASSIGNMENT_STATUSES),
+  /** Why PoliNetwork Auth refused the change, when `status` is `refused`. */
+  refusal: z.string().nullable(),
 })
+export type Assignment = z.infer<typeof assignmentSchema>
 
 export const accountSchema = z.discriminatedUnion("status", [
   z.object({ status: z.literal("none") }),
@@ -97,31 +79,32 @@ export const accountSchema = z.discriminatedUnion("status", [
     expiresOn: z.string(),
     sentBy: z.string(),
   }),
-  z.object({ status: z.literal("linked"), email: z.string(), via: z.string(), linkedOn: z.string(), how: z.string() }),
-  // Record matching is gone: a record the current backend still holds for review reads as not linked.
-  z.object({ status: z.literal("review") }).transform(() => ({ status: "none" as const })),
+  z.object({
+    status: z.literal("linked"),
+    sub: z.string(),
+    /** `auth` for a record People created for a role given by hand in PoliNetwork Auth. */
+    method: z.enum(["invite", "manual", "auth"]),
+    linkedOn: z.string().nullable(),
+    /** Who linked it: the invitee for an invite, `auth` for a record created from Auth. */
+    linkedBy: z.string().nullable(),
+  }),
 ])
+export type Account = z.infer<typeof accountSchema>
 
-export const consentsSchema = z.object({
-  privacy: z.object({ version: z.string(), acceptedOn: z.string() }).nullable(),
-  photo: z.object({ status: z.enum(PHOTO_CONSENTS), on: z.string() }).nullable(),
-})
-
-/** One row of the People lists: everything but notes, activity and discrepancies. */
+/** One row of the People lists: everything but notes, activity and audit fields. */
 export const personRowSchema = z.object({
   id: z.string(),
-  profile: profileSchema,
-  admin: adminRoleSchema.nullable(),
-  teams: z.array(teamMembershipSchema),
-  consents: consentsSchema,
+  firstName: z.string(),
+  lastName: z.string(),
+  /** Only for sending invites, never to match accounts. `null` without contact rights. */
+  contactEmail: z.string().nullable(),
+  /** `null` without contact rights. */
+  phone: z.string().nullable(),
+  /** Informational only. */
+  telegramUsername: z.string().nullable(),
+  /** `none` without `people:read`, except on one's own record. */
   account: accountSchema,
-})
-
-export const discrepancySchema = z.object({
-  /** Only `telegram-mismatch` offers an action; the current backend may still send kinds about members and the census. */
-  kind: z.string(),
-  message: z.string(),
-  suggestedTelegram: z.string().nullable(),
+  assignments: z.array(assignmentSchema),
 })
 
 export const activitySchema = z.object({ actor: z.string(), text: z.string(), at: z.string() })
@@ -129,23 +112,41 @@ export const activitySchema = z.object({ actor: z.string(), text: z.string(), at
 export const personRecordSchema = personRowSchema.extend({
   /** `null` without `people:read`. */
   notes: z.string().nullable(),
-  discrepancies: z.array(discrepancySchema),
+  /** Newest first; empty without `people:read`. */
   activity: z.array(activitySchema),
+  createdBy: z.string(),
+  createdAt: z.string(),
+  updatedBy: z.string(),
+  updatedAt: z.string(),
 })
 
-export type Profile = z.infer<typeof profileSchema>
-export type AdminRole = z.infer<typeof adminRoleSchema>
-export type TeamFields = z.infer<typeof teamFieldsSchema>
-export type TeamMembership = z.infer<typeof teamMembershipSchema>
-export type Account = z.infer<typeof accountSchema>
-export type Consents = z.infer<typeof consentsSchema>
 export type PersonRow = z.infer<typeof personRowSchema>
 export type PersonRecord = z.infer<typeof personRecordSchema>
-export type Discrepancy = z.infer<typeof discrepancySchema>
+export type Activity = z.infer<typeof activitySchema>
+export type TeamFields = z.infer<typeof teamFieldsSchema>
+
+export const adminSummarySchema = z.object({
+  person: personRowSchema,
+  /** The current admin assignment. */
+  admin: assignmentSchema,
+  /** The current Capo Admin assignment, when they are also one. */
+  capo: assignmentSchema.nullable(),
+})
+export type AdminSummary = z.infer<typeof adminSummarySchema>
+
+export const capoSummarySchema = z.object({
+  person: personRowSchema,
+  capo: assignmentSchema,
+  /** Current admins who have them as Capo Admin of reference. */
+  admins: z.array(personRefSchema),
+})
+export type CapoSummary = z.infer<typeof capoSummarySchema>
 
 export const teamSummarySchema = z.object({
   id: teamIdSchema,
   name: z.string(),
+  /** Whether PoliNetwork Auth binds a role to this team. Without one, nobody can be added. */
+  assignable: z.object({ member: z.boolean(), lead: z.boolean() }),
   lead: personRefSchema.nullable(),
   members: z.array(personRowSchema),
 })
@@ -161,18 +162,30 @@ export const inviteSchema = z.object({
 })
 export type Invite = z.infer<typeof inviteSchema>
 
+/** A link made in the last 30 days, so a mistake (or a forwarded invite) is easy to spot and undo. */
+export const recentLinkSchema = z.object({
+  person: personRefSchema,
+  sub: z.string(),
+  /** The account's directory email, when the IdP lists it. */
+  email: z.string().nullable(),
+  method: z.enum(["invite", "manual", "auth"]),
+  linkedOn: z.string(),
+  linkedBy: z.string().nullable(),
+})
+export type RecentLink = z.infer<typeof recentLinkSchema>
+
+/** What the invite landing page shows before the signed-in account confirms. */
+export const invitePreviewSchema = z.object({ personId: z.string(), name: z.string(), expiresOn: z.string() })
+export type InvitePreview = z.infer<typeof invitePreviewSchema>
+
 export const accountMatchSchema = z.object({
   id: z.string(),
   name: z.string(),
   email: z.string(),
-  telegram: z.string().nullable(),
-  via: z.string(),
   linkedTo: personRefSchema.nullable(),
-  reason: z.enum(["same-telegram", "same-email", "similar-name"]),
 })
 export type AccountMatch = z.infer<typeof accountMatchSchema>
 
-/** Telegram › Capo Admin: the Capo Admin's scope and the admins who have them as Capo Admin of reference. */
 export const capoAreaSchema = z.object({
   scope: z.string(),
   admins: z.array(personRowSchema),
@@ -206,7 +219,7 @@ export const myAreaSchema = z.discriminatedUnion("state", [
           z.object({
             id: z.string(),
             name: z.string(),
-            role: z.enum(["member", "lead"]),
+            role: z.enum(TEAM_ROLES),
             telegram: z.string().nullable(),
           })
         ),
@@ -214,8 +227,6 @@ export const myAreaSchema = z.discriminatedUnion("state", [
       .nullable(),
   }),
   z.object({ state: z.literal("none") }),
-  // Record matching is gone: a first-sign-in match from the current backend reads as no record yet.
-  z.object({ state: z.literal("match") }).transform(() => ({ state: "none" as const })),
 ])
 export type MyArea = z.infer<typeof myAreaSchema>
 
@@ -237,7 +248,7 @@ export const TEAMS = {
     ],
   },
   design: {
-    name: "Design & Social",
+    name: "Design & Marketing",
     fields: [
       {
         key: "tools",
@@ -278,6 +289,9 @@ export const personIdSchema = z.string().regex(/^P-\d{4}$/)
 const dateSchema = z.iso.date()
 const opaqueIdSchema = z.string().min(1).max(128)
 const reasonSchema = z.string().trim().min(1).max(500)
+/** Starts the reason an unlink sends Auth, which takes at most 500 characters; the record's history keeps the rest. */
+export const UNLINK_REASON = "Unlinked from People: "
+const capoScopeSchema = z.string().trim().min(1).max(120)
 /** Telegram's own rule: 5–32 letters, digits or underscores. Empty when unknown; a leading @ is dropped. */
 export const TELEGRAM_USERNAME_PATTERN = /^@?[A-Za-z0-9_]{5,32}$/
 const telegramUsernameSchema = z
@@ -289,30 +303,36 @@ const telegramUsernameSchema = z
 export const personInputSchema = z.object({
   firstName: z.string().trim().min(1).max(80),
   lastName: z.string().trim().min(1).max(80),
-  personalEmail: z.email().max(254),
+  /** Empty when unknown. */
+  contactEmail: z.union([z.literal(""), z.email().max(254)]),
+  /** Empty when unknown. */
   phone: z.string().trim().max(40),
+  /** Empty when unknown. */
   telegramUsername: telegramUsernameSchema,
-  course: z.string().trim().min(1).max(120),
-  year: z.enum(YEARS),
-  campus: campusSchema,
 })
-export const createPersonInputSchema = personInputSchema.extend({ admin: z.boolean() })
+export const createPersonInputSchema = personInputSchema
 export const updatePersonInputSchema = personInputSchema.extend({ id: personIdSchema })
 export const setNoteInputSchema = z.object({ id: personIdSchema, note: z.string().trim().max(2000) })
 
-export const endAdminInputSchema = z.object({ personId: personIdSchema, reason: reasonSchema })
-export const capoScopeInputSchema = z.object({ personId: personIdSchema, scope: z.string().trim().max(120).nullable() })
+export const assignAdminInputSchema = z.object({
+  personId: personIdSchema,
+  since: dateSchema,
+  capoId: personIdSchema.nullable(),
+})
+export const endAssignmentInputSchema = z.object({ personId: personIdSchema, reason: reasonSchema })
 export const capoRefInputSchema = z.object({ personId: personIdSchema, capoId: personIdSchema.nullable() })
+export const appointCapoInputSchema = z.object({ personId: personIdSchema, since: dateSchema, scope: capoScopeSchema })
+export const capoScopeInputSchema = z.object({ personId: personIdSchema, scope: capoScopeSchema })
 
 export const addTeamMemberInputSchema = z.object({
   teamId: teamIdSchema,
   personId: personIdSchema,
-  role: z.enum(["member", "lead"]),
+  role: z.enum(TEAM_ROLES),
   since: dateSchema,
   fields: teamFieldsInput,
 })
 export const teamCandidatesInputSchema = z.object({ teamId: teamIdSchema })
-export const teamCandidateSchema = z.object({ id: z.string(), name: z.string(), course: z.string() })
+export const teamCandidateSchema = z.object({ id: z.string(), name: z.string() })
 export type TeamCandidate = z.infer<typeof teamCandidateSchema>
 export const teamFieldsInputSchema = z.object({
   teamId: teamIdSchema,
@@ -322,36 +342,39 @@ export const teamFieldsInputSchema = z.object({
 export const endTeamInputSchema = z.object({
   teamId: teamIdSchema,
   personId: personIdSchema,
-  lastDay: dateSchema,
   reason: reasonSchema,
-  note: z.string().trim().max(500),
 })
 
 export const personRefInputSchema = z.object({ personId: personIdSchema })
-export const searchAccountsInputSchema = z.object({ personId: personIdSchema, query: z.string().trim().max(120) })
+export const inviteTokenSchema = z.string().regex(/^[A-Za-z0-9_-]{43}$/)
+export const inviteTokenInputSchema = z.object({ token: inviteTokenSchema })
+export const unlinkAccountInputSchema = z.object({
+  personId: personIdSchema,
+  reason: reasonSchema.max(500 - UNLINK_REASON.length),
+})
+export const searchAccountsInputSchema = z.object({ query: z.string().trim().max(120) })
 export const linkAccountInputSchema = z.object({
   personId: personIdSchema,
   accountId: opaqueIdSchema,
   reason: reasonSchema,
 })
 
-/** The token from an invite link, `/dashboard/account/me?peopleInvite=<token>`. */
-export const inviteTokenSchema = z.string().regex(/^[A-Za-z0-9_-]{43}$/)
-export const acceptInviteInputSchema = z.object({ token: inviteTokenSchema })
-export type AcceptInviteInput = z.infer<typeof acceptInviteInputSchema>
-
+export type PersonInput = z.infer<typeof personInputSchema>
 export type CreatePersonInput = z.infer<typeof createPersonInputSchema>
 export type UpdatePersonInput = z.infer<typeof updatePersonInputSchema>
 export type SetNoteInput = z.infer<typeof setNoteInputSchema>
-export type EndAdminInput = z.infer<typeof endAdminInputSchema>
-export type CapoScopeInput = z.infer<typeof capoScopeInputSchema>
+export type AssignAdminInput = z.infer<typeof assignAdminInputSchema>
+export type EndAssignmentInput = z.infer<typeof endAssignmentInputSchema>
 export type CapoRefInput = z.infer<typeof capoRefInputSchema>
+export type AppointCapoInput = z.infer<typeof appointCapoInputSchema>
+export type CapoScopeInput = z.infer<typeof capoScopeInputSchema>
 export type AddTeamMemberInput = z.infer<typeof addTeamMemberInputSchema>
 export type TeamFieldsInput = z.infer<typeof teamFieldsInputSchema>
 export type TeamCandidatesInput = z.infer<typeof teamCandidatesInputSchema>
 export type EndTeamInput = z.infer<typeof endTeamInputSchema>
 export type SearchAccountsInput = z.infer<typeof searchAccountsInputSchema>
 export type LinkAccountInput = z.infer<typeof linkAccountInputSchema>
+export type UnlinkAccountInput = z.infer<typeof unlinkAccountInputSchema>
 
 export const createdSchema = z.object({ id: z.string() })
 
@@ -359,3 +382,31 @@ export const createdSchema = z.object({ id: z.string() })
 export function teamFields(team: TeamId): TeamField[] {
   return TEAMS[team].fields
 }
+
+// Dashboard-only names for the contract's parts.
+
+export const ACCOUNT_STATUSES = ["none", "invite", "linked"] as const
+export type AccountStatus = Account["status"]
+export type AssignmentStatus = (typeof ASSIGNMENT_STATUSES)[number]
+export type AssignmentKind = (typeof ASSIGNMENT_KINDS)[number]
+export type TeamRole = (typeof TEAM_ROLES)[number]
+/** A person's record, or one row of a list: both carry the assignments. */
+export type PersonLike = Pick<PersonRow, "id" | "firstName" | "lastName" | "assignments" | "account">
+
+/**
+ * Add person: the record, then the roles it starts with. The backend creates the record and each assignment in
+ * separate calls; a Capo Admin needs the Admin role too.
+ */
+export const newPersonInputSchema = createPersonInputSchema
+  .extend({
+    admin: z.boolean(),
+    capoScope: capoScopeSchema.nullable(),
+    teams: z
+      .array(z.object({ team: teamIdSchema, role: z.enum(TEAM_ROLES) }))
+      .max(TEAM_IDS.length)
+      .refine((teams) => new Set(teams.map((entry) => entry.team)).size === teams.length, "Each team once."),
+  })
+  .refine((input) => input.admin || input.capoScope === null, "A Capo Admin must be an admin too.")
+export type NewPersonInput = z.infer<typeof newPersonInputSchema>
+/** The new record, and the roles the backend refused to start it with, in its words. */
+export type NewPersonResult = { id: string; refused: { role: string; message: string }[] }
diff --git a/src/features/people/people.fake.server.ts b/src/features/people/people.fake.server.ts
index b708bc5..8ee0be7 100644
--- a/src/features/people/people.fake.server.ts
+++ b/src/features/people/people.fake.server.ts
@@ -2,45 +2,83 @@ import { createHash } from "node:crypto"
 
 import type { PeopleApi, PeopleViewer } from "./people.api.server"
 import {
-  type AccountMatch,
-  type CapoArea,
-  type Discrepancy,
+  type Account,
+  type Assignment,
   type MyArea,
   type PersonRecord,
   type PersonRow,
   TEAM_IDS,
   TEAMS,
   type TeamId,
-  type TeamSummary,
+  type TeamRole,
 } from "./people.contract"
-import { addDays, buildPeopleStore, type PeopleStore, type StoredPerson } from "./people.fixtures.server"
+import {
+  addDays,
+  BOUND_TEAM_ROLES,
+  buildPeopleStore,
+  type PeopleStore,
+  REFUSAL,
+  REFUSING_ACCOUNTS,
+  type StoredAssignment,
+  type StoredPerson,
+} from "./people.fixtures.server"
 
 /**
  * Agent mode's stand-in for the backend's `people.*` procedures, over `people.fixtures.server.ts`. State lives for the
- * dev server's lifetime, so mutations show up on reload. It enforces the same visibility rules the backend must:
- * contacts and notes only with `people:read`, a Capo Admin's scope, or a Team Lead's team.
+ * dev server's lifetime, so mutations show up on reload. It follows the backend's rules where a page depends on them:
+ * contacts and notes only with `people:read`; `people:write` for admins and team members, `people:appoint` for Leads
+ * and Capo Admins, a Lead for their team's members; nobody gives themselves a role, though anyone may give one up.
+ * Fake Auth confirms a change to a linked record a few seconds after it is sent, and refuses every change for
+ * `REFUSING_ACCOUNTS`.
  */
 
 let store: PeopleStore | null = null
-/** The agent user's own state: the record linked through an invite link, which replaces `AGENT_PERSON`. */
-type SelfState = { invitedId: string | null }
-const self: SelfState = { invitedId: null }
+/** The record the agent user linked through an invite link, which replaces `AGENT_PERSON`. */
+let invitedId: string | null = null
+/** How long fake Auth takes to confirm a change. */
+const AUTH_DELAY = 4000
 
 function data() {
   store ??= buildPeopleStore()
+  settle(store)
   return store
 }
 
+/**
+ * Fake Auth answers: changes sent long enough ago are confirmed. As in the backend, a confirmed end of a Capo Admin
+ * role leaves their admins without a Capo Admin of reference.
+ */
+function settle(current: PeopleStore) {
+  const now = Date.now()
+  for (const person of current.people)
+    for (const assignment of person.assignments)
+      if (assignment.status === "sent" && assignment.settlesAt !== null && assignment.settlesAt <= now) {
+        Object.assign(assignment, { status: "applied", settlesAt: null })
+        log(person, "system", "PoliNetwork Auth confirmed the change")
+        if (assignment.kind === "capo" && assignment.change === "end") clearCapoReferences(current, person, "system")
+      }
+}
+
+/** Once a Capo Admin's role has ended, the admins who had them as reference have none. */
+function clearCapoReferences(current: PeopleStore, capo: StoredPerson, actor: string) {
+  for (const other of current.people) {
+    const admin = other.assignments.find((a) => a.endedOn === null && a.kind === "admin")
+    if (admin?.capoOfReference?.id !== capo.id) continue
+    admin.capoOfReference = null
+    log(other, actor, `Their Capo Admin of reference, ${capo.id}, ended`)
+  }
+}
+
 function today() {
   return new Date().toISOString().slice(0, 10)
 }
 
-function nowStamp() {
-  return new Date().toISOString()
+function fullName(person: Pick<StoredPerson, "firstName" | "lastName">) {
+  return `${person.firstName} ${person.lastName}`
 }
 
-function fullName(person: StoredPerson) {
-  return `${person.profile.firstName} ${person.profile.lastName}`
+function ref(person: StoredPerson) {
+  return { id: person.id, name: fullName(person) }
 }
 
 function find(id: string) {
@@ -50,129 +88,261 @@ function find(id: string) {
 }
 
 function log(person: StoredPerson, actor: string, text: string) {
-  person.activity.unshift({ actor, text, at: nowStamp() })
-}
-
-function discrepancies(person: StoredPerson): Discrepancy[] {
-  if (!person.censusTelegram || person.censusTelegram === person.profile.telegramUsername) return []
-  return [
-    {
-      kind: "telegram-mismatch",
-      message: `The 2026/27 census says @${person.censusTelegram}, but the record says @${person.profile.telegramUsername ?? "—"}.`,
-      suggestedTelegram: person.censusTelegram,
-    },
-  ]
-}
-
-/** The contract row, with contacts kept only when `withContacts`. */
-function row(person: StoredPerson, withContacts: boolean): PersonRow {
-  return {
-    id: person.id,
-    profile: {
-      ...person.profile,
-      personalEmail: withContacts ? person.profile.personalEmail : null,
-      phone: withContacts ? person.profile.phone : null,
-    },
-    admin: person.admin,
-    teams: person.teams,
-    consents: person.consents,
-    account: person.account,
-  }
+  person.activity.unshift({ actor, text, at: new Date().toISOString() })
 }
 
-function record(person: StoredPerson, viewer: PeopleViewer): PersonRecord {
-  const canRead = viewer.permissions.includes("people:read")
-  const ownRecord = linkedRecord(viewer)?.id === person.id
-  return {
-    ...row(person, canRead || ownRecord),
-    notes: canRead ? person.notes : null,
-    discrepancies: canRead ? discrepancies(person) : [],
-    activity: [...person.activity].sort((a, b) => (a.at < b.at ? 1 : -1)),
-  }
+function touch(person: StoredPerson, actor: string) {
+  person.updatedBy = actor
+  person.updatedAt = new Date().toISOString()
 }
 
 function require(viewer: PeopleViewer, permission: string) {
   if (!viewer.permissions.includes(permission)) throw new Error("UNAUTHORIZED")
 }
 
-function viewerName(viewer: PeopleViewer) {
-  const person = viewer.personId ? data().byId.get(viewer.personId) : undefined
-  return person ? fullName(person) : "Agent"
-}
-
-/** The record the signed-in person acts as: the one an invite linked, or `AGENT_PERSON`. */
-function linkedRecord(viewer: PeopleViewer) {
-  if (self.invitedId) return data().byId.get(self.invitedId) ?? null
-  if (!viewer.personId || viewer.personId === "none") return null
-  return data().byId.get(viewer.personId) ?? null
-}
-
 /**
  * An invite link's token. Agent mode derives it from the record and the send date, so links survive a dev server
- * restart (to switch `AGENT_PERSON`); the backend issues random tokens and stores them hashed.
+ * restart; the backend issues random tokens and stores them hashed.
  */
 function inviteToken(personId: string, sentOn: string) {
   return createHash("sha256").update(`people-invite:${personId}:${sentOn}`).digest("base64url")
 }
 
+function current(person: StoredPerson, kind: Assignment["kind"], team?: TeamId) {
+  return person.assignments.find(
+    (a) => a.endedOn === null && a.kind === kind && (team === undefined || a.team === team)
+  )
+}
+
+/** Current and in effect, as the backend's `confirmed`: not ended, and not a start still waiting for Auth. */
+function confirmed(assignment: Assignment) {
+  return assignment.endedOn === null && !(assignment.change === "start" && assignment.status === "sent")
+}
+
+/** The current assignment of a kind (and team) when it is in effect. */
+function confirmedOf(person: StoredPerson, kind: Assignment["kind"], team?: TeamId) {
+  const assignment = current(person, kind, team)
+  return assignment && confirmed(assignment) ? assignment : undefined
+}
+
 function leadsOf(person: StoredPerson | null): TeamId[] {
   if (!person) return []
-  return person.teams.filter((team) => team.role === "lead" && !team.endedOn).map((team) => team.team)
+  return person.assignments.flatMap((a) =>
+    a.kind === "team" && a.teamRole === "lead" && confirmed(a) && a.team ? [a.team] : []
+  )
+}
+
+function account(person: StoredPerson): Account {
+  if (person.accountSub)
+    return {
+      status: "linked",
+      sub: person.accountSub,
+      method: person.linkMethod ?? "manual",
+      linkedOn: person.linkedOn,
+      linkedBy: person.linkedBy,
+    }
+  if (person.invite) return { status: "invite", ...person.invite }
+  return { status: "none" }
+}
+
+/** A role Auth binds to People: `admin`, `capo`, or `team:<team>:<role>`. */
+type Binding = { kind: "admin" } | { kind: "capo" } | { kind: "team"; team: TeamId; role: TeamRole }
+
+function bindingOf(assignment: Assignment): Binding {
+  if (assignment.kind === "team" && assignment.team && assignment.teamRole)
+    return { kind: "team", team: assignment.team, role: assignment.teamRole }
+  return assignment.kind === "capo" ? { kind: "capo" } : { kind: "admin" }
+}
+
+function assignmentView({ settlesAt, ...assignment }: StoredAssignment): Assignment {
+  void settlesAt
+  return assignment
 }
 
 export function fakePeopleApi(viewer: PeopleViewer): PeopleApi {
-  const actor = viewerName(viewer)
+  const canRead = viewer.permissions.includes("people:read")
+  /** The record the signed-in person acts as: the one an invite linked, or `AGENT_PERSON`. */
+  const mine = () => {
+    if (invitedId) return data().byId.get(invitedId) ?? null
+    if (!viewer.personId || viewer.personId === "none") return null
+    const person = data().byId.get(viewer.personId) ?? null
+    return person?.accountSub ? person : null
+  }
+  const sub = () => mine()?.accountSub ?? "sub-agent"
+  const leads = (team: TeamId) => viewer.permissions.includes("people:self") && leadsOf(mine()).includes(team)
+
+  function row(person: StoredPerson, scopedContacts = false): PersonRow {
+    const own = person.accountSub !== null && person.accountSub === sub()
+    const contacts = own || canRead || scopedContacts
+    return {
+      id: person.id,
+      firstName: person.firstName,
+      lastName: person.lastName,
+      contactEmail: contacts ? person.contactEmail : null,
+      phone: contacts ? person.phone : null,
+      telegramUsername: person.telegramUsername,
+      account: own || canRead ? account(person) : { status: "none" },
+      assignments: person.assignments.map(assignmentView),
+    }
+  }
+
+  function record(person: StoredPerson): PersonRecord {
+    return {
+      ...row(person),
+      notes: canRead ? person.notes : null,
+      activity: canRead ? [...person.activity].sort((a, b) => (a.at < b.at ? 1 : -1)) : [],
+      createdBy: person.createdBy,
+      createdAt: person.createdAt,
+      updatedBy: person.updatedBy,
+      updatedAt: person.updatedAt,
+    }
+  }
+
+  /**
+   * The same gate as the backend's `rules.ts`, for the bindings agent mode knows. Nobody gives themselves a role, but
+   * giving one up is always allowed; a role that isn't bound can still be ended.
+   */
+  function authorize(person: StoredPerson, binding: Binding, action: "assign" | "unassign") {
+    if (action === "assign" && binding.kind === "team" && !BOUND_TEAM_ROLES[binding.team][binding.role])
+      throw new Error(
+        `No role is bound to team:${binding.team}:${binding.role} in PoliNetwork Auth, so it can't be assigned.`
+      )
+    const own = person.accountSub !== null && person.accountSub === sub()
+    if (own && action === "assign") throw new Error("Nobody can give themselves a role.")
+    const appointment = binding.kind === "capo" || (binding.kind === "team" && binding.role === "lead")
+    if (own) {
+      // Giving up one's own role.
+    } else if (appointment) require(viewer, "people:appoint")
+    else if (!viewer.permissions.includes("people:write") && !(binding.kind === "team" && leads(binding.team)))
+      throw new Error("UNAUTHORIZED")
+    if (person.accountSub && person.assignments.some((a) => a.status === "sent"))
+      throw new Error("A change for this person is waiting for PoliNetwork Auth: try again once it answers.")
+  }
+
+  /** A change to the record's roles: pending while it isn't linked, sent to fake Auth once it is. */
+  function push(person: StoredPerson, assignment: StoredAssignment) {
+    if (!person.accountSub) {
+      assignment.status = "pending"
+      return
+    }
+    if (REFUSING_ACCOUNTS.has(person.accountSub)) {
+      if (assignment.change === "start")
+        Object.assign(assignment, { endedOn: today(), endReason: "Refused by PoliNetwork Auth" })
+      else Object.assign(assignment, { endedOn: null, endReason: null })
+      Object.assign(assignment, { status: "refused", refusal: REFUSAL })
+      log(person, sub(), `PoliNetwork Auth refused: ${REFUSAL}`)
+      throw new Error(REFUSAL)
+    }
+    Object.assign(assignment, { status: "sent", refusal: null, settlesAt: Date.now() + AUTH_DELAY })
+  }
+
+  function start(person: StoredPerson, fields: Partial<StoredAssignment> & Pick<Assignment, "kind" | "since">) {
+    if (fields.since > today()) throw new Error("Start date is in the future")
+    const assignment: StoredAssignment = {
+      id: `A-${String(data().nextAssignment++).padStart(4, "0")}`,
+      team: null,
+      teamRole: null,
+      capoScope: null,
+      capoOfReference: null,
+      fields: {},
+      endedOn: null,
+      endReason: null,
+      assignedBy: sub(),
+      change: "start",
+      status: "pending",
+      refusal: null,
+      settlesAt: null,
+      ...fields,
+    }
+    person.assignments.push(assignment)
+    touch(person, sub())
+    return assignment
+  }
+
+  function end(person: StoredPerson, assignment: StoredAssignment, reason: string) {
+    Object.assign(assignment, { endedOn: today(), endReason: reason, change: "end" })
+    touch(person, sub())
+  }
+
+  function capoRef(capoId: string | null, personId: string) {
+    if (!capoId) return null
+    const capo = find(capoId)
+    if (capo.id === personId || !current(capo, "capo")) throw new Error("Choose a current Capo Admin")
+    return ref(capo)
+  }
+
+  function teamAccess(team: TeamId, write: boolean) {
+    if (viewer.permissions.includes(write ? "people:write" : "people:read")) return
+    if (!leads(team)) throw new Error("You do not lead this team")
+  }
+
+  function inviteAccess(person: StoredPerson) {
+    if (viewer.permissions.includes("people:write")) return
+    const teams = person.assignments.flatMap((a) => (a.kind === "team" && a.endedOn === null && a.team ? [a.team] : []))
+    if (!teams.some(leads))
+      throw new Error("Inviting needs people:write and admin:access, or leading one of the person's teams")
+  }
+
+  function inviteFor(token: string) {
+    const person = data().people.find(
+      (candidate) =>
+        candidate.invite &&
+        !candidate.accountSub &&
+        inviteToken(candidate.id, candidate.invite.sentOn) === token &&
+        candidate.invite.expiresOn >= today()
+    )
+    if (!person) throw new Error("This invite link is no longer valid: ask for a new one")
+    return person
+  }
+
+  /** Links the account and sends the pending assignments to fake Auth. */
+  function link(person: StoredPerson, accountSub: string, actor: string, method: "invite" | "manual", how: string) {
+    if (person.accountSub) throw new Error("Unlink the existing account first")
+    const other = data().people.find((candidate) => candidate.accountSub === accountSub)
+    if (other) throw new Error(`This account is already linked to ${other.id}`)
+    Object.assign(person, { accountSub, linkMethod: method, linkedOn: today(), linkedBy: actor, invite: null })
+    touch(person, actor)
+    log(person, actor, `Linked account ${accountSub} (${method === "invite" ? "email invite" : "by hand"}): ${how}`)
+    for (const assignment of person.assignments)
+      if (assignment.endedOn === null && assignment.status === "pending")
+        Object.assign(assignment, { status: "sent", settlesAt: Date.now() + AUTH_DELAY })
+  }
+
   return {
     listPeople: async () => {
       require(viewer, "people:read")
-      return data().people.map((person) => row(person, true))
+      return data().people.map((person) => row(person))
     },
     getPerson: async (id) => {
       require(viewer, "people:read")
-      return record(find(id), viewer)
+      return record(find(id))
     },
     createPerson: async (input) => {
       require(viewer, "people:write")
       const { people, byId } = data()
-      if (people.some((person) => person.profile.personalEmail === input.personalEmail)) {
-        throw new Error(`${input.personalEmail} already belongs to another record.`)
-      }
       const id = `P-${String(people.length + 1).padStart(4, "0")}`
+      const now = new Date().toISOString()
       const person: StoredPerson = {
         id,
-        family: "inf",
-        profile: {
-          firstName: input.firstName,
-          lastName: input.lastName,
-          personalEmail: input.personalEmail || null,
-          phone: input.phone || null,
-          telegramUsername: input.telegramUsername || null,
-          telegramId: null,
-          course: input.course,
-          year: input.year,
-          campus: input.campus,
-          otherAssociations: [],
-          studentRepresentative: null,
-        },
-        admin: input.admin
-          ? {
-              status: "active",
-              since: today(),
-              endedOn: null,
-              endReason: null,
-              availableAsCapo: false,
-              capoOfReference: null,
-              capoScope: null,
-            }
-          : null,
-        teams: [],
-        consents: { privacy: null, photo: null },
-        account: { status: "none" },
+        firstName: input.firstName,
+        lastName: input.lastName,
+        contactEmail: input.contactEmail || null,
+        phone: input.phone || null,
+        telegramUsername: input.telegramUsername || null,
         notes: null,
+        accountSub: null,
+        linkMethod: null,
+        linkedOn: null,
+        linkedBy: null,
+        invite: null,
+        assignments: [],
         activity: [],
-        censusTelegram: null,
+        createdBy: sub(),
+        createdAt: now,
+        updatedBy: sub(),
+        updatedAt: now,
       }
-      log(person, actor, "created the record")
+      log(person, sub(), "Created the record")
       people.push(person)
       byId.set(id, person)
       return { id }
@@ -180,337 +350,309 @@ export function fakePeopleApi(viewer: PeopleViewer): PeopleApi {
     updatePerson: async (input) => {
       require(viewer, "people:write")
       const person = find(input.id)
-      Object.assign(person.profile, {
+      Object.assign(person, {
         firstName: input.firstName,
         lastName: input.lastName,
-        personalEmail: input.personalEmail || null,
+        contactEmail: input.contactEmail || null,
         phone: input.phone || null,
         telegramUsername: input.telegramUsername || null,
-        course: input.course,
-        year: input.year,
-        campus: input.campus,
       })
-      log(person, actor, "edited the profile")
+      touch(person, sub())
+      log(person, sub(), "Updated the record")
     },
     setNote: async (input) => {
       require(viewer, "people:write")
       const person = find(input.id)
       person.notes = input.note || null
-      log(person, actor, "edited the HR notes")
+      touch(person, sub())
+      log(person, sub(), "Updated the HR note")
+    },
+
+    listAdmins: async () => {
+      require(viewer, "people:read")
+      return data().people.flatMap((person) => {
+        const admin = current(person, "admin")
+        if (!admin) return []
+        const capo = current(person, "capo")
+        return [{ person: row(person), admin: assignmentView(admin), capo: capo ? assignmentView(capo) : null }]
+      })
+    },
+    assignAdmin: async (input) => {
+      const person = find(input.personId)
+      authorize(person, { kind: "admin" }, "assign")
+      if (current(person, "admin")) throw new Error("Already an admin")
+      const assignment = start(person, {
+        kind: "admin",
+        since: input.since,
+        capoOfReference: capoRef(input.capoId, person.id),
+      })
+      log(person, sub(), "Made admin")
+      push(person, assignment)
     },
     endAdmin: async (input) => {
+      const person = find(input.personId)
+      const assignment = current(person, "admin")
+      if (!assignment) throw new Error("Not a current admin")
+      authorize(person, { kind: "admin" }, "unassign")
+      if (current(person, "capo")) throw new Error("End their Capo Admin appointment first")
+      end(person, assignment, input.reason)
+      log(person, sub(), `Ended admin: ${input.reason}`)
+      push(person, assignment)
+    },
+    setCapoOfReference: async (input) => {
       require(viewer, "people:write")
       const person = find(input.personId)
-      if (!person.admin || person.admin.status !== "active") throw new Error("This person isn't an active admin.")
-      if (person.admin.capoScope) require(viewer, "people:appoint")
-      Object.assign(person.admin, {
-        status: "former",
-        endedOn: today(),
-        endReason: input.reason,
-        capoScope: null,
+      const assignment = current(person, "admin")
+      if (!assignment) throw new Error("Not a current admin")
+      assignment.capoOfReference = capoRef(input.capoId, person.id)
+      touch(person, sub())
+      log(
+        person,
+        sub(),
+        input.capoId ? `Capo Admin of reference: ${input.capoId}` : "Cleared the Capo Admin of reference"
+      )
+    },
+
+    listCapos: async () => {
+      require(viewer, "people:read")
+      return data().people.flatMap((person) => {
+        const capo = current(person, "capo")
+        if (!capo) return []
+        const admins = data().people.filter((other) => current(other, "admin")?.capoOfReference?.id === person.id)
+        return [{ person: row(person), capo: assignmentView(capo), admins: admins.map(ref) }]
       })
-      log(person, actor, `ended the admin role: ${input.reason}`)
+    },
+    appointCapo: async (input) => {
+      const person = find(input.personId)
+      authorize(person, { kind: "capo" }, "assign")
+      if (!current(person, "admin")) throw new Error("Make them an admin first")
+      if (current(person, "capo")) throw new Error("Already a Capo Admin")
+      const assignment = start(person, { kind: "capo", since: input.since, capoScope: input.scope })
+      log(person, sub(), `Appointed Capo Admin for ${input.scope}`)
+      push(person, assignment)
     },
     setCapoScope: async (input) => {
       require(viewer, "people:appoint")
       const person = find(input.personId)
-      if (!person.admin || person.admin.status !== "active") throw new Error("Only active admins can be Capo Admins.")
-      person.admin.capoScope = input.scope
-      log(
-        person,
-        actor,
-        input.scope ? `appointed ${person.profile.firstName} Capo Admin of ${input.scope}` : "ended the Capo Admin role"
-      )
+      const assignment = current(person, "capo")
+      if (!assignment) throw new Error("Not a current Capo Admin")
+      assignment.capoScope = input.scope
+      touch(person, sub())
+      log(person, sub(), `Capo Admin scope: ${input.scope}`)
     },
-    setCapoOfReference: async (input) => {
-      require(viewer, "people:write")
+    endCapo: async (input) => {
       const person = find(input.personId)
-      if (!person.admin || person.admin.status !== "active") throw new Error("Only active admins have a Capo Admin.")
-      if (input.capoId === null) {
-        person.admin.capoOfReference = null
-        log(person, actor, "removed the Capo Admin of reference")
-        return
-      }
-      const capo = find(input.capoId)
-      if (!capo.admin?.capoScope) throw new Error(`${fullName(capo)} isn't a Capo Admin.`)
-      person.admin.capoOfReference = { id: capo.id, name: fullName(capo) }
-      log(person, actor, `set ${fullName(capo)} as Capo Admin of reference`)
+      const assignment = current(person, "capo")
+      if (!assignment) throw new Error("Not a current Capo Admin")
+      authorize(person, { kind: "capo" }, "unassign")
+      end(person, assignment, input.reason)
+      // For a linked record, once Auth confirms (`settle`): a refusal keeps them Capo Admin of the same admins.
+      if (!person.accountSub) clearCapoReferences(data(), person, sub())
+      log(person, sub(), `Ended Capo Admin: ${input.reason}`)
+      push(person, assignment)
     },
+
     listTeams: async () => {
-      const canRead = viewer.permissions.includes("people:read")
-      const leads = leadsOf(linkedRecord(viewer))
-      if (!canRead && !leads.length) throw new Error("UNAUTHORIZED")
-      const teams: TeamSummary[] = []
-      for (const id of TEAM_IDS) {
-        if (!canRead && !leads.includes(id)) continue
-        const members = data().people.filter((person) => person.teams.some((team) => team.team === id))
-        const lead = members.find((person) =>
-          person.teams.some((team) => team.team === id && team.role === "lead" && !team.endedOn)
+      const allowed = TEAM_IDS.filter((team) => canRead || leads(team))
+      if (!allowed.length) throw new Error("UNAUTHORIZED")
+      return allowed.map((id) => {
+        const members = data().people.filter((person) =>
+          person.assignments.some((a) => a.team === id && (canRead || confirmed(a)))
         )
-        teams.push({
+        const lead = members.find((person) => leadsOf(person).includes(id))
+        return {
           id,
           name: TEAMS[id].name,
-          lead: lead ? { id: lead.id, name: fullName(lead) } : null,
-          // A Lead sees contacts of current members only, not of people who left the team.
-          members: members.map((person) =>
-            row(person, canRead || person.teams.some((team) => team.team === id && !team.endedOn))
-          ),
-        })
-      }
-      return teams
+          assignable: BOUND_TEAM_ROLES[id],
+          lead: lead ? ref(lead) : null,
+          members: members.map((person) => {
+            const result = row(person, true)
+            if (!canRead) result.assignments = result.assignments.filter((a) => a.team === id && a.endedOn === null)
+            return result
+          }),
+        }
+      })
     },
     listTeamCandidates: async (input) => {
-      const canRead = viewer.permissions.includes("people:read")
-      if (!canRead && !leadsOf(linkedRecord(viewer)).includes(input.teamId)) throw new Error("UNAUTHORIZED")
+      teamAccess(input.teamId, false)
       return data()
-        .people.filter((person) => !person.teams.some((team) => team.team === input.teamId && !team.endedOn))
-        .map((person) => ({ id: person.id, name: fullName(person), course: person.profile.course }))
-        .toSorted((a, b) => a.name.localeCompare(b.name))
+        .people.filter((person) => !current(person, "team", input.teamId))
+        .map(ref)
     },
     addTeamMember: async (input) => {
-      const canWrite = viewer.permissions.includes("people:write")
-      if (!canWrite && !leadsOf(linkedRecord(viewer)).includes(input.teamId)) throw new Error("UNAUTHORIZED")
-      if (input.role === "lead") require(viewer, "people:appoint")
       const person = find(input.personId)
-      if (person.teams.some((team) => team.team === input.teamId && !team.endedOn)) {
-        throw new Error(`${fullName(person)} is already in ${TEAMS[input.teamId].name}.`)
-      }
-      person.teams.push({
+      authorize(person, { kind: "team", team: input.teamId, role: input.role }, "assign")
+      if (current(person, "team", input.teamId)) throw new Error("Already in this team")
+      if (
+        input.role === "lead" &&
+        data().people.some((other) => current(other, "team", input.teamId)?.teamRole === "lead")
+      )
+        throw new Error("End the existing Lead appointment first")
+      const assignment = start(person, {
+        kind: "team",
         team: input.teamId,
-        role: input.role,
+        teamRole: input.role,
         since: input.since,
-        endedOn: null,
-        endReason: null,
         fields: input.fields,
       })
-      log(
-        person,
-        actor,
-        `added ${person.profile.firstName} to ${TEAMS[input.teamId].name} as ${input.role === "lead" ? "Team Lead" : "Member"}`
-      )
+      log(person, sub(), `Joined ${input.teamId} as ${input.role}`)
+      push(person, assignment)
     },
     updateTeamFields: async (input) => {
-      const canWrite = viewer.permissions.includes("people:write")
-      if (!canWrite && !leadsOf(linkedRecord(viewer)).includes(input.teamId)) throw new Error("UNAUTHORIZED")
-      const membership = find(input.personId).teams.find((team) => team.team === input.teamId && !team.endedOn)
-      if (!membership) throw new Error("This membership has ended.")
-      membership.fields = input.fields
+      teamAccess(input.teamId, true)
+      const person = find(input.personId)
+      const assignment = current(person, "team", input.teamId)
+      if (!assignment) throw new Error("Not in this team")
+      assignment.fields = input.fields
+      touch(person, sub())
+      log(person, sub(), `Updated ${input.teamId} fields`)
     },
     endTeamMembership: async (input) => {
-      const canWrite = viewer.permissions.includes("people:write")
-      if (!canWrite && !leadsOf(linkedRecord(viewer)).includes(input.teamId)) throw new Error("UNAUTHORIZED")
       const person = find(input.personId)
-      const membership = person.teams.find((team) => team.team === input.teamId && !team.endedOn)
-      if (!membership) throw new Error("This membership has already ended.")
-      if (membership.role === "lead") require(viewer, "people:appoint")
-      membership.endedOn = input.lastDay
-      membership.endReason = input.reason
-      log(person, actor, `ended the ${TEAMS[input.teamId].name} membership: ${input.reason}`)
+      const assignment = current(person, "team", input.teamId)
+      if (!assignment?.teamRole) throw new Error("Not in this team")
+      authorize(person, { kind: "team", team: input.teamId, role: assignment.teamRole }, "unassign")
+      end(person, assignment, input.reason)
+      log(person, sub(), `Left ${input.teamId}: ${input.reason}`)
+      push(person, assignment)
     },
+
     listInvites: async () => {
       require(viewer, "people:read")
       return data().people.flatMap((person) =>
-        person.account.status === "invite"
-          ? [
-              {
-                personId: person.id,
-                name: fullName(person),
-                email: person.account.email,
-                sentOn: person.account.sentOn,
-                expiresOn: person.account.expiresOn,
-                sentBy: person.account.sentBy,
-              },
-            ]
-          : []
+        person.invite && !person.accountSub ? [{ personId: person.id, name: fullName(person), ...person.invite }] : []
       )
     },
+    listRecentLinks: async () => {
+      require(viewer, "people:read")
+      const since = addDays(today(), -30)
+      const { people, directory } = data()
+      return people
+        .filter((person) => person.accountSub && person.linkedOn && person.linkedOn >= since)
+        .sort((a, b) => ((a.linkedOn ?? "") < (b.linkedOn ?? "") ? 1 : -1))
+        .map((person) => ({
+          person: ref(person),
+          sub: person.accountSub ?? "",
+          email: directory.find((entry) => entry.sub === person.accountSub)?.email ?? null,
+          method: person.linkMethod ?? "manual",
+          linkedOn: person.linkedOn ?? today(),
+          linkedBy: person.linkedBy,
+        }))
+    },
     sendInvite: async (input) => {
-      require(viewer, "people:write")
       const person = find(input.personId)
-      if (person.account.status === "linked") throw new Error(`${fullName(person)} has already linked an account.`)
-      if (!person.profile.personalEmail) throw new Error("Add a personal email before sending an invite.")
-      person.account = {
-        status: "invite",
-        email: person.profile.personalEmail,
-        sentOn: today(),
-        expiresOn: addDays(today(), 14),
-        sentBy: actor,
-      }
-      log(person, actor, `sent an invite to ${person.profile.personalEmail}`)
-      // Agent mode sends no email: the link goes to the dev server's console instead.
-      console.info(
-        `[agent mode] Invite link for ${person.id}: /dashboard/account/me?peopleInvite=${inviteToken(person.id, today())}`
-      )
+      inviteAccess(person)
+      if (person.accountSub || !person.contactEmail) throw new Error("Account already linked or contact email missing")
+      const sentOn = today()
+      person.invite = { email: person.contactEmail, sentOn, expiresOn: addDays(sentOn, 14), sentBy: sub() }
+      log(person, sub(), "Queued an account invite")
+      console.info(`[agent mode] Invite link for ${person.id}: /people/invite?token=${inviteToken(person.id, sentOn)}`)
     },
     revokeInvite: async (input) => {
-      require(viewer, "people:write")
       const person = find(input.personId)
-      if (person.account.status !== "invite") throw new Error("There is no pending invite.")
-      person.account = { status: "none" }
-      log(person, actor, "revoked the invite")
+      inviteAccess(person)
+      if (!person.invite) throw new Error("No open invite")
+      person.invite = null
+      log(person, sub(), "Revoked the account invite")
     },
     searchAccounts: async (input) => {
-      require(viewer, "people:write")
-      const person = find(input.personId)
-      const { firstName, lastName, personalEmail, telegramUsername } = person.profile
-      const otherFirst = `${firstName.slice(0, -1)}${firstName.endsWith("a") ? "o" : "a"}`
-      const accounts: AccountMatch[] = [
-        {
-          id: "acc-1",
-          name: fullName(person),
-          email: personalEmail ?? `${firstName.toLowerCase()}@gmail.com`,
-          telegram: telegramUsername ? `@${telegramUsername}` : null,
-          via: "Signed in with Telegram on 13 Oct 2026",
-          linkedTo: null,
-          reason: "same-telegram",
-        },
-        {
-          id: "acc-2",
-          name: `${firstName} ${lastName}ni`,
-          email: `${firstName[0].toLowerCase()}.${lastName.toLowerCase()}ni@outlook.it`,
-          telegram: null,
-          via: "Signed in with Google on 2 Oct 2026",
-          linkedTo: null,
-          reason: "similar-name",
-        },
-        {
-          id: "acc-3",
-          name: `${otherFirst} ${lastName}`,
-          email: `${otherFirst.toLowerCase()}.${lastName.toLowerCase()}@mail.polimi.it`,
-          telegram: null,
-          via: "Signed in with Microsoft 365 on 28 Sep 2026",
-          linkedTo: { id: "P-0057", name: `${otherFirst} ${lastName}` },
-          reason: "similar-name",
-        },
-      ]
-      const query = input.query.toLowerCase().replace(/^@/, "")
-      return query
-        ? accounts.filter((account) =>
-            `${account.name} ${account.email} ${account.telegram ?? ""}`.toLowerCase().includes(query)
-          )
-        : accounts
+      require(viewer, "people:link")
+      const query = input.query.toLowerCase()
+      const { directory, people } = data()
+      return directory
+        .filter((entry) => !query || `${entry.name} ${entry.email} ${entry.sub}`.toLowerCase().includes(query))
+        .slice(0, 100)
+        .map((entry) => {
+          const linked = people.find((person) => person.accountSub === entry.sub)
+          return { id: entry.sub, name: entry.name, email: entry.email, linkedTo: linked ? ref(linked) : null }
+        })
     },
     linkAccount: async (input) => {
-      require(viewer, "people:write")
-      const person = find(input.personId)
-      const accounts = await fakePeopleApi(viewer).searchAccounts({ personId: input.personId, query: "" })
-      const account = accounts.find((candidate) => candidate.id === input.accountId)
-      if (!account) throw new Error("This account no longer exists.")
-      if (account.linkedTo) {
-        throw new Error(
-          `This account is already linked to ${account.linkedTo.name} (${account.linkedTo.id}). Unlink it there first, or pick another account.`
-        )
-      }
-      person.account = {
-        status: "linked",
-        email: account.email,
-        via: account.via.split(" on ")[0].replace("Signed in with ", ""),
-        linkedOn: today(),
-        how: `Linked by ${actor}`,
-      }
-      log(person, actor, `linked ${account.email}: ${input.reason}`)
+      require(viewer, "people:link")
+      const entry = data().directory.find((candidate) => candidate.sub === input.accountId)
+      if (!entry) throw new Error("IdP account not found")
+      if (entry.sub === sub()) throw new Error("Ask someone else to link your own account")
+      link(find(input.personId), entry.sub, sub(), "manual", input.reason)
     },
     unlinkAccount: async (input) => {
-      require(viewer, "people:write")
+      require(viewer, "people:link")
       const person = find(input.personId)
-      if (person.account.status !== "linked") throw new Error("No account is linked.")
-      log(person, actor, `unlinked ${person.account.email}`)
-      person.account = { status: "none" }
+      if (!person.accountSub) throw new Error("Account not linked")
+      if (person.assignments.some((a) => a.status === "sent"))
+        throw new Error("A change for this person is waiting for PoliNetwork Auth: try again once it answers.")
+      for (const assignment of person.assignments)
+        if (assignment.endedOn === null) {
+          authorize(person, bindingOf(assignment), "unassign")
+        }
+      // Fake Auth takes the roles back at once; the assignments wait for the next link.
+      log(person, sub(), `Unlinked account ${person.accountSub}: ${input.reason}`)
+      for (const assignment of person.assignments)
+        if (assignment.endedOn === null)
+          Object.assign(assignment, { status: "pending", change: "start", refusal: null, settlesAt: null })
+      Object.assign(person, { accountSub: null, linkMethod: null, linkedOn: null, linkedBy: null })
+      touch(person, sub())
     },
+
     getCapoArea: async () => {
       require(viewer, "people:self")
-      const me = linkedRecord(viewer)
-      const scope = me?.admin?.status === "active" ? me.admin.capoScope : null
-      if (!me || !scope) throw new Error("UNAUTHORIZED")
-      const admins = data().people.filter(
-        (person) => person.admin?.status === "active" && person.admin.capoOfReference?.id === me.id
-      )
+      const person = mine()
+      const scope = person ? confirmedOf(person, "capo")?.capoScope : null
+      if (!person || !scope) throw new Error("UNAUTHORIZED")
       return {
         scope,
-        admins: admins.map((person) => ({
-          ...row(person, true),
-          profile: { ...person.profile, personalEmail: null },
-        })),
-      } satisfies CapoArea
+        admins: data()
+          .people.filter((other) => confirmedOf(other, "admin")?.capoOfReference?.id === person.id)
+          .map((other) => ({ ...row(other, true), contactEmail: null, phone: null })),
+      }
     },
     getMyRoles: async () => {
-      const me = linkedRecord(viewer)
-      return { capoScope: me?.admin?.capoScope ?? null, leads: leadsOf(me) }
+      require(viewer, "people:self")
+      const person = mine()
+      return { capoScope: (person && confirmedOf(person, "capo")?.capoScope) ?? null, leads: leadsOf(person) }
     },
-    getMyArea: async () => {
+    getMyArea: async (): Promise<MyArea> => {
       require(viewer, "people:self")
-      const me = linkedRecord(viewer)
-      if (!me) return { state: "none" } satisfies MyArea
+      const person = mine()
+      if (!person) return { state: "none" }
+      const teams = person.assignments.flatMap((a) => (a.kind === "team" && confirmed(a) && a.team ? [a.team] : []))
       const contacts: Extract<MyArea, { state: "linked" }>["contacts"] = []
-      const capo = me.admin?.capoOfReference ? data().byId.get(me.admin.capoOfReference.id) : undefined
-      if (capo)
-        contacts.push({
-          role: "capo",
-          name: fullName(capo),
-          telegram: capo.profile.telegramUsername,
-          team: null,
-        })
-      for (const membership of me.teams.filter((team) => !team.endedOn)) {
-        const lead = data().people.find(
-          (person) =>
-            person !== me &&
-            person.teams.some((team) => team.team === membership.team && team.role === "lead" && !team.endedOn)
-        )
-        if (lead)
-          contacts.push({
-            role: "lead",
-            name: fullName(lead),
-            telegram: lead.profile.telegramUsername,
-            team: membership.team,
-          })
+      const capoId = confirmedOf(person, "admin")?.capoOfReference?.id
+      const capo = capoId ? data().byId.get(capoId) : undefined
+      if (capo && confirmedOf(capo, "capo"))
+        contacts.push({ role: "capo", name: fullName(capo), telegram: capo.telegramUsername, team: null })
+      for (const other of data().people) {
+        for (const team of leadsOf(other).filter((led) => teams.includes(led)))
+          contacts.push({ role: "lead", name: fullName(other), telegram: other.telegramUsername, team })
+        if (confirmedOf(other, "team", "hr"))
+          contacts.push({ role: "hr", name: fullName(other), telegram: other.telegramUsername, team: "hr" })
       }
-      contacts.push({ role: "hr", name: "HR team", telegram: null, team: null })
-      const team = me.teams.find((membership) => !membership.endedOn)?.team ?? null
-      const roster = team
-        ? {
-            team,
-            members: data()
-              .people.flatMap((person) => {
-                const membership = person.teams.find((candidate) => candidate.team === team && !candidate.endedOn)
-                if (!membership) return []
-                return [
-                  {
-                    id: person.id,
-                    name: fullName(person),
-                    role: membership.role,
-                    telegram: person.profile.telegramUsername,
-                  },
-                ]
-              })
-              .sort((a, b) => (a.role === b.role ? a.name.localeCompare(b.name) : a.role === "lead" ? -1 : 1)),
-          }
-        : null
+      const [team] = teams
       return {
         state: "linked",
-        person: { ...record(me, { ...viewer, personId: me.id }), notes: null },
+        person: record(person),
         contacts,
-        roster,
-      } satisfies MyArea
+        roster: team
+          ? {
+              team,
+              members: data().people.flatMap((other) => {
+                const assignment = confirmedOf(other, "team", team)
+                return assignment?.teamRole
+                  ? [{ ...ref(other), role: assignment.teamRole, telegram: other.telegramUsername }]
+                  : []
+              }),
+            }
+          : null,
+      }
+    },
+    previewInvite: async (input) => {
+      const person = inviteFor(input.token)
+      return { personId: person.id, name: fullName(person), expiresOn: person.invite?.expiresOn ?? today() }
     },
     acceptInvite: async (input) => {
-      require(viewer, "people:self")
-      if (linkedRecord(viewer)) throw new Error("Your account is already linked to a record.")
-      // The token alone identifies the invited record.
-      const me = data().people.find(
-        (person) =>
-          person.account.status === "invite" &&
-          person.account.expiresOn >= today() &&
-          inviteToken(person.id, person.account.sentOn) === input.token
-      )
-      if (me?.account.status !== "invite") throw new Error("This invitation has expired or was revoked.")
-      self.invitedId = me.id
-      me.account = {
-        status: "linked",
-        email: me.account.email,
-        via: "Email",
-        linkedOn: today(),
-        how: "Accepted the email invitation",
-      }
+      const person = inviteFor(input.token)
+      // Agent mode accepts as a fresh account; from then on it acts as the invited record.
+      link(person, "sub-agent", "sub-agent", "invite", "Accepted the email invite")
+      invitedId = person.id
     },
   }
 }
diff --git a/src/features/people/people.fixtures.server.ts b/src/features/people/people.fixtures.server.ts
index 3f8109b..a9113e0 100644
--- a/src/features/people/people.fixtures.server.ts
+++ b/src/features/people/people.fixtures.server.ts
@@ -1,139 +1,127 @@
-import {
-  type Account,
-  type AdminRole,
-  CAMPUSES,
-  type PersonRecord,
-  type TeamFields,
-  type TeamId,
-  type TeamMembership,
-} from "./people.contract"
+import { type Activity, type Assignment, TEAM_IDS, type TeamId } from "./people.contract"
 
 /**
- * Agent-mode sample data for the People area, ported from the prototype's `buildData()` (docs/people/prototype):
- * 148 people, ~40 linked accounts, ~110 admins and 27 team members, with the same seed and key people. Soci, fees,
- * receipts, the census and record matching are gone (#138); their mockups keep their own data in `mockup-data.ts`.
+ * Agent mode's sample register. Deterministic, so the same records come back after a dev server restart. It covers
+ * every case the pages show: linked and unlinked records, open and expired invites, and assignments in every status
+ * (pending until linked, waiting for Auth, applied, refused by Auth with its reason), current and ended.
  */
 
-export type FamilyId = "inf" | "ges" | "ind" | "ele" | "des" | "arc"
+export type StoredAssignment = Assignment & {
+  /** For `sent`: when fake Auth confirms it. `null` keeps it waiting (Auth not answering). */
+  settlesAt: number | null
+}
+
+export type StoredInvite = { email: string; sentOn: string; expiresOn: string; sentBy: string }
 
-/** A record as the fake backend stores it: the contract's record plus what it derives views from. */
-export type StoredPerson = Omit<PersonRecord, "discrepancies"> & {
-  family: FamilyId
-  /** A Telegram username reported elsewhere that differs from the record: a `telegram-mismatch` discrepancy. */
-  censusTelegram: string | null
+export type StoredPerson = {
+  id: string
+  firstName: string
+  lastName: string
+  contactEmail: string | null
+  phone: string | null
+  telegramUsername: string | null
+  notes: string | null
+  accountSub: string | null
+  linkMethod: "invite" | "manual" | "auth" | null
+  linkedOn: string | null
+  linkedBy: string | null
+  invite: StoredInvite | null
+  assignments: StoredAssignment[]
+  activity: Activity[]
+  createdBy: string
+  createdAt: string
+  updatedBy: string
+  updatedAt: string
 }
 
+/** A sign-in account in the IdP directory, for linking by hand. */
+export type DirectoryAccount = { sub: string; name: string; email: string }
+
 export type PeopleStore = {
   people: StoredPerson[]
   byId: Map<string, StoredPerson>
+  directory: DirectoryAccount[]
+  nextAssignment: number
 }
 
+/** Roles PoliNetwork Auth binds to People. Events has no Lead role bound, so nobody can be appointed its Lead. */
+export const BOUND_TEAM_ROLES = {
+  it: { member: true, lead: true },
+  hr: { member: true, lead: true },
+  design: { member: true, lead: true },
+  intl: { member: true, lead: true },
+  events: { member: true, lead: false },
+} satisfies Record<TeamId, { member: boolean; lead: boolean }>
+
+/** Accounts fake Auth refuses every change for, as if their assigner had lost clearance. */
+export const REFUSING_ACCOUNTS = new Set(["sub-0012"])
+export const REFUSAL = "The actor can't give a role with permissions they don't hold: tg:messages:delete"
+
 const FIRST = [
   "Giulia",
-  "Davide",
+  "Marco",
   "Sara",
-  "Matteo",
-  "Elena",
-  "Marta",
   "Luca",
-  "Marco",
   "Chiara",
-  "Federico",
-  "Alessia",
-  "Tommaso",
+  "Matteo",
   "Francesca",
-  "Lorenzo",
-  "Sofia",
-  "Andrea",
-  "Martina",
+  "Davide",
+  "Elena",
   "Alessandro",
+  "Martina",
+  "Lorenzo",
+  "Alice",
+  "Federico",
   "Giorgia",
   "Riccardo",
   "Beatrice",
+  "Tommaso",
+  "Anna",
   "Simone",
+  "Sofia",
+  "Andrea",
+  "Ilaria",
+  "Pietro",
   "Valentina",
   "Gabriele",
-  "Aurora",
-  "Pietro",
+  "Laura",
+  "Nicolò",
   "Camilla",
-  "Edoardo",
-  "Ludovica",
   "Filippo",
+  "Arianna",
+  "Edoardo",
   "Noemi",
-  "Nicolò",
-  "Elisa",
-  "Giacomo",
-  "Anna",
   "Stefano",
   "Irene",
-  "Michele",
-  "Greta",
   "Emanuele",
-  "Ilaria",
-  "Daniele",
-  "Arianna",
-  "Leonardo",
-  "Benedetta",
-  "Samuele",
-  "Rebecca",
-  "Christian",
-  "Alice",
-  "Mattia",
-  "Gaia",
-  "Jacopo",
-  "Laura",
-  "Alberto",
-  "Silvia",
+  "Marta",
+  "Giacomo",
+  "Elisa",
   "Paolo",
-  "Eleonora",
-  "Antonio",
-  "Caterina",
-  "Vittoria",
-  "Giovanni",
-  "Margherita",
-  "Enrico",
-  "Carlotta",
-  "Fabio",
-  "Bianca",
-  "Diego",
-  "Serena",
-  "Nicole",
-  "Manuel",
-  "Federica",
-  "Kevin",
-  "Asia",
-  "Yasmine",
-  "Omar",
 ]
-
 const LAST = [
   "Rossi",
-  "Russo",
-  "Ferrari",
-  "Esposito",
   "Bianchi",
-  "Romano",
   "Colombo",
-  "Ricci",
-  "Marino",
-  "Greco",
-  "Bruno",
+  "Ferrari",
+  "Russo",
+  "Romano",
   "Gallo",
-  "Conti",
-  "De Luca",
-  "Mancini",
   "Costa",
-  "Giordano",
-  "Rizzo",
-  "Lombardi",
+  "Fontana",
+  "Conti",
+  "Esposito",
+  "Ricci",
+  "Bruno",
   "Moretti",
+  "Marino",
+  "Greco",
   "Barbieri",
-  "Fontana",
-  "Santoro",
-  "Mariani",
+  "Lombardi",
+  "Giordano",
   "Rinaldi",
   "Caruso",
-  "Ferri",
+  "Ferrara",
   "Galli",
   "Martini",
   "Leone",
@@ -141,653 +129,224 @@ const LAST = [
   "Gentile",
   "Martinelli",
   "Vitale",
-  "Lombardo",
   "Serra",
   "Coppola",
-  "De Santis",
-  "D'Angelo",
+  "De Luca",
+  "Mancini",
+  "Santoro",
   "Marchetti",
-  "Parisi",
-  "Villa",
-  "Conte",
-  "Ferraro",
+  "Cattaneo",
   "Fabbri",
-  "Bianco",
-  "Marini",
-  "Grasso",
-  "Valentini",
-  "Messina",
-  "Sala",
-  "De Angelis",
-  "Gatti",
   "Pellegrini",
-  "Palumbo",
-  "Sanna",
-  "Farina",
-  "Rizzi",
-  "Monti",
-  "Cattaneo",
-  "Morelli",
-  "Amato",
-  "Silvestri",
-  "Mazza",
-  "Testa",
-  "Grassi",
-  "Carbone",
-  "Giuliani",
-  "Benedetti",
-  "Barone",
-  "Caputo",
-  "Montanari",
-  "Guerra",
-  "Palmieri",
-  "Bernardi",
-  "Fiore",
-  "De Rosa",
-  "Ferretti",
-  "Bellini",
-  "Basile",
-  "Riva",
-  "Donati",
-  "Piras",
-  "Sartori",
-  "Neri",
-  "Milani",
-  "Pagano",
-  "Orlando",
-  "Negri",
-  "Brambilla",
-  "Crippa",
-  "Mauri",
-  "Pozzi",
-  "Galbiati",
-]
-
-type Course = { name: string; family: FamilyId; campuses: string[]; degree: "b" | "m"; weight: number }
-
-const COURSES: Course[] = [
-  {
-    name: "Ingegneria Informatica",
-    family: "inf",
-    campuses: ["Leonardo", "Leonardo", "Leonardo", "Cremona"],
-    degree: "b",
-    weight: 11,
-  },
-  { name: "Computer Science and Engineering", family: "inf", campuses: ["Leonardo"], degree: "m", weight: 3 },
-  { name: "Ingegneria Gestionale", family: "ges", campuses: ["Bovisa", "Bovisa", "Cremona"], degree: "b", weight: 7 },
-  { name: "Management Engineering", family: "ges", campuses: ["Bovisa"], degree: "m", weight: 2 },
-  { name: "Ingegneria Meccanica", family: "ind", campuses: ["Bovisa", "Piacenza", "Lecco"], degree: "b", weight: 5 },
-  { name: "Ingegneria Aerospaziale", family: "ind", campuses: ["Bovisa"], degree: "b", weight: 4 },
-  { name: "Ingegneria Energetica", family: "ind", campuses: ["Bovisa", "Piacenza"], degree: "b", weight: 2 },
-  { name: "Ingegneria Chimica", family: "ind", campuses: ["Leonardo"], degree: "b", weight: 2 },
-  { name: "Ingegneria Elettronica", family: "ele", campuses: ["Leonardo"], degree: "b", weight: 3 },
-  { name: "Ingegneria Biomedica", family: "ele", campuses: ["Leonardo"], degree: "b", weight: 4 },
-  { name: "Ingegneria Matematica", family: "ele", campuses: ["Leonardo"], degree: "b", weight: 2 },
-  { name: "Design della Comunicazione", family: "des", campuses: ["Bovisa"], degree: "b", weight: 4 },
-  { name: "Design del Prodotto Industriale", family: "des", campuses: ["Bovisa"], degree: "b", weight: 3 },
-  { name: "Design degli Interni", family: "des", campuses: ["Bovisa"], degree: "b", weight: 2 },
-  { name: "Architettura", family: "arc", campuses: ["Leonardo", "Mantova", "Piacenza"], degree: "b", weight: 4 },
-  { name: "Ingegneria Civile", family: "arc", campuses: ["Leonardo", "Lecco"], degree: "b", weight: 2 },
+  "Villa",
+  "Ferri",
 ]
 
-export const COURSE_NAMES = COURSES.map((course) => course.name)
-
-/** The Capo Admin scope of each family of courses. */
-export const FAMILIES = {
-  inf: { scope: "Ingegneria Informatica" },
-  ges: { scope: "Ingegneria Gestionale" },
-  ind: { scope: "Ingegneria Industriale" },
-  ele: { scope: "Ingegneria dell'Informazione" },
-  des: { scope: "Design" },
-  arc: { scope: "Architettura" },
-} satisfies Record<FamilyId, { scope: string }>
-
-export const FAMILY_IDS: FamilyId[] = ["inf", "ges", "ind", "ele", "des", "arc"]
+const HR_SUB = "sub-0002"
 
-const REPS = ["Consiglio di Corso di Studio", "Giunta di Scuola", "Consiglio degli Studenti", "Senato Accademico"]
-const ASSOCIATIONS = [
-  "Skyward",
-  "Dynamis PRC",
-  "ESN Politecnico Milano",
-  "BEST Milano",
-  "JEMP",
-  "PoliMi Sailing Team",
-  "Poli Radio",
-]
-const NOTES = [
-  "Prefers to be contacted on Telegram.",
-  "Away on Erasmus from February to July.",
-  "Interested in joining IT next semester.",
-  "Asked to step down as admin at the end of the year.",
-  "Helped run the freshers' open day.",
-]
+export function addDays(date: string, days: number) {
+  const next = new Date(`${date}T12:00:00Z`)
+  next.setUTCDate(next.getUTCDate() + days)
+  return next.toISOString().slice(0, 10)
+}
 
-type KeyPerson = {
-  first: string
-  last: string
-  course: string
-  family: FamilyId
-  year: string
-  campus: string
-  tg: string
+function today() {
+  return new Date().toISOString().slice(0, 10)
 }
 
-const KEYS = {
-  "P-0142": {
-    first: "Giulia",
-    last: "Rossi",
-    course: "Ingegneria Informatica",
-    family: "inf",
-    year: "2nd year",
-    campus: "Leonardo",
-    tg: "giuliarossi",
-  },
-  "P-0098": {
-    first: "Davide",
-    last: "Russo",
-    course: "Computer Science and Engineering",
-    family: "inf",
-    year: "1st year MSc",
-    campus: "Leonardo",
-    tg: "davide_russo",
-  },
-  "P-0034": {
-    first: "Sara",
-    last: "Galli",
-    course: "Computer Science and Engineering",
-    family: "inf",
-    year: "2nd year MSc",
-    campus: "Leonardo",
-    tg: "saragalli",
-  },
-  "P-0115": {
-    first: "Matteo",
-    last: "Conti",
-    course: "Ingegneria Informatica",
-    family: "inf",
-    year: "2nd year",
-    campus: "Leonardo",
-    tg: "matteoconti",
-  },
-  "P-0063": {
-    first: "Elena",
-    last: "Ricci",
-    course: "Ingegneria Gestionale",
-    family: "ges",
-    year: "2nd year",
-    campus: "Bovisa",
-    tg: "elenaricci",
-  },
-  "P-0007": {
-    first: "Marta",
-    last: "Colombo",
-    course: "Management Engineering",
-    family: "ges",
-    year: "2nd year MSc",
-    campus: "Bovisa",
-    tg: "martacolombo",
-  },
-  "P-0021": {
-    first: "Luca",
-    last: "Ferri",
-    course: "Ingegneria Biomedica",
-    family: "ele",
-    year: "3rd year",
-    campus: "Leonardo",
-    tg: "lucaferri",
-  },
-  "P-0045": {
-    first: "Alessia",
-    last: "Fontana",
-    course: "Design della Comunicazione",
-    family: "des",
-    year: "3rd year",
-    campus: "Bovisa",
-    tg: "alessiafontana",
-  },
-  "P-0052": {
-    first: "Tommaso",
-    last: "Greco",
-    course: "Architettura",
-    family: "arc",
-    year: "2nd year",
-    campus: "Mantova",
-    tg: "tommygreco",
-  },
-  "P-0088": {
-    first: "Marco",
-    last: "Bianchi",
-    course: "Ingegneria Meccanica",
-    family: "ind",
-    year: "2nd year",
-    campus: "Piacenza",
-    tg: "marcobianchi",
-  },
-  "P-0131": {
-    first: "Chiara",
-    last: "Esposito",
-    course: "Design degli Interni",
-    family: "des",
-    year: "Graduated",
-    campus: "External",
-    tg: "chiaraesp",
-  },
-  "P-0076": {
-    first: "Federico",
-    last: "Marino",
-    course: "Ingegneria Aerospaziale",
-    family: "ind",
-    year: "1st year",
-    campus: "Bovisa",
-    tg: "fedemarino",
-  },
-} satisfies Record<string, KeyPerson>
+function pad(value: number) {
+  return String(value).padStart(4, "0")
+}
 
-/** Lowercase ASCII without spaces or apostrophes, for emails and usernames. */
 export function slug(text: string) {
   return text
     .normalize("NFD")
     .replace(/[̀-ͯ]/g, "")
-    .replace(/['\s]/g, "")
     .toLowerCase()
+    .replace(/[^a-z]/g, "")
 }
 
-export function addDays(date: string, days: number) {
-  const next = new Date(`${date}T12:00:00Z`)
-  next.setUTCDate(next.getUTCDate() + days)
-  return next.toISOString().slice(0, 10)
-}
-
-function pad(value: number, width: number) {
-  return String(value).padStart(width, "0")
-}
-
-function mulberry32(seed: number) {
-  let state = seed
-  return () => {
-    state = (state + 0x6d2b79f5) | 0
-    let t = Math.imul(state ^ (state >>> 15), 1 | state)
-    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t
-    return ((t ^ (t >>> 14)) >>> 0) / 4294967296
-  }
-}
+/** Which record has which account, invite and roles; the numbers are record IDs. */
+const LINKED = new Set([1, 2, 3, 4, 5, 6, 7, 9, 10, 12, 13, 15, 16, 18, 19, 21, 22, 24, 25, 27, 30, 31, 33, 36])
+const INVITED = new Set([8, 11, 14, 26, 34])
+const EXPIRED_INVITE = 14
+const ADMINS = [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
+/** Capo Admins and the admins who answer to each. */
+const CAPOS = [
+  { capo: 7, scope: "Ingegneria Informatica", admins: [9, 10, 11, 12] },
+  { capo: 3, scope: "Ingegneria Gestionale", admins: [13, 14, 15] },
+  { capo: 5, scope: "Design", admins: [16, 17, 18] },
+]
+const TEAMS_OF = {
+  it: { lead: 7, members: [1, 21, 22, 23, 24, 25], former: [28] },
+  hr: { lead: 2, members: [26, 27, 29], former: [] },
+  design: { lead: 30, members: [31, 32, 33], former: [35] },
+  intl: { lead: 36, members: [37, 38], former: [] },
+  events: { lead: null, members: [39, 40, 34], former: [] },
+} satisfies Record<TeamId, { lead: number | null; members: number[]; former: number[] }>
+/** Sent to Auth and not confirmed: an admin start and a team end. */
+const WAITING = { admin: 19, teamEnd: 24 }
 
-function campusOf(value: string) {
-  const campus = CAMPUSES.find((candidate) => candidate === value)
-  if (!campus) throw new Error(`Unknown campus ${value}`)
-  return campus
-}
+const FIELDS = {
+  it: (n) => ({ github: `dev${n}`, areas: n % 2 ? ["Frontend", "Backend"] : ["Bot"] }),
+  hr: (n) => ({ focus: n % 2 ? ["Recruiting"] : ["Onboarding", "Census"] }),
+  design: (n) => ({ tools: n % 2 ? ["Figma", "Illustrator"] : ["Photoshop"], portfolio: "" }),
+  intl: (n) => ({ languages: n % 2 ? ["English", "Spanish"] : ["English", "French"] }),
+  events: (n) => ({ focus: n % 2 ? ["Partnerships"] : ["Logistics"] }),
+} satisfies Record<TeamId, (n: number) => Record<string, string | string[]>>
 
 export function buildPeopleStore(): PeopleStore {
-  const random = mulberry32(1442)
-  const pick = <T>(items: readonly T[]) => items[Math.floor(random() * items.length)]
-  const weighted = (items: Course[]) => {
-    let remaining = random() * items.reduce((sum, item) => sum + item.weight, 0)
-    for (const item of items) {
-      remaining -= item.weight
-      if (remaining < 0) return item
-    }
-    return items[items.length - 1]
-  }
-  const sample = <T>(items: readonly T[], count: number) => {
-    const pool = [...items]
-    const out: T[] = []
-    while (out.length < count && pool.length) out.push(pool.splice(Math.floor(random() * pool.length), 1)[0])
-    return out
-  }
-  const shuffle = <T>(items: readonly T[]) => {
-    const copy = [...items]
-    for (let index = copy.length - 1; index > 0; index--) {
-      const other = Math.floor(random() * (index + 1))
-      ;[copy[index], copy[other]] = [copy[other], copy[index]]
-    }
-    return copy
-  }
-  const randomDate = (from: string, to: string) => {
-    const start = Date.parse(`${from}T12:00:00Z`)
-    const end = Date.parse(`${to}T12:00:00Z`)
-    return new Date(start + Math.floor(random() * (end - start))).toISOString().slice(0, 10)
-  }
-
-  const used = new Set(Object.values(KEYS).map((key) => `${key.first} ${key.last}`))
+  const now = today()
+  let nextAssignment = 1
   const people: StoredPerson[] = []
-  for (let index = 0; index < 148; index++) {
-    let first = pick(FIRST)
-    let last = pick(LAST)
-    while (used.has(`${first} ${last}`)) {
-      first = pick(FIRST)
-      last = pick(LAST)
-    }
-    used.add(`${first} ${last}`)
-    const course = weighted(COURSES)
-    let year =
-      course.degree === "m"
-        ? pick(["1st year MSc", "2nd year MSc"])
-        : pick(["1st year", "2nd year", "2nd year", "3rd year", "3rd year"])
-    if (random() < 0.06) year = "Graduated"
-    const campus = year === "Graduated" && random() < 0.5 ? "External" : pick(course.campuses)
-    const f = slug(first)
-    const l = slug(last)
-    const domain = pick([
-      "gmail.com",
-      "gmail.com",
-      "gmail.com",
-      "outlook.it",
-      "icloud.com",
-      "mail.polimi.it",
-      "libero.it",
-    ])
-    const phone = `+39 3${Math.floor(random() * 10)}${Math.floor(random() * 10)} ${100 + Math.floor(random() * 900)} ${1000 + Math.floor(random() * 9000)}`
-    const telegram =
-      random() < 0.9
-        ? pick([f + l, `${f}_${l[0]}`, f[0] + l, `${f}${l.slice(0, 3)}${10 + Math.floor(random() * 90)}`])
-        : null
-    people.push({
-      id: `P-${pad(index + 1, 4)}`,
-      family: course.family,
-      profile: {
-        firstName: first,
-        lastName: last,
-        personalEmail: `${f}.${l}@${domain}`,
-        phone,
-        telegramUsername: telegram,
-        telegramId: String(110000000 + Math.floor(random() * 7800000000)),
-        course: course.name,
-        year,
-        campus: campusOf(campus),
-        otherAssociations: [],
-        studentRepresentative: null,
-      },
-      admin: null,
-      teams: [],
-      consents: { privacy: null, photo: null },
-      account: { status: "none" },
-      notes: random() < 0.1 ? pick(NOTES) : null,
-      activity: [],
-      censusTelegram: null,
-    })
-  }
-  const byId = new Map(people.map((person) => [person.id, person]))
-  const person = (id: string) => {
-    const found = byId.get(id)
-    if (!found) throw new Error(`Unknown person ${id}`)
-    return found
-  }
-  for (const [id, key] of Object.entries(KEYS)) {
-    const target = person(id)
-    target.family = key.family
-    Object.assign(target.profile, {
-      firstName: key.first,
-      lastName: key.last,
-      course: key.course,
-      year: key.year,
-      campus: campusOf(key.campus),
-      telegramUsername: key.tg,
-      personalEmail: `${slug(key.first)}.${slug(key.last)}@gmail.com`,
-    })
-  }
-  person("P-0142").profile.personalEmail = "giulia.rossi.02@gmail.com"
 
-  // Admin and team data accumulate here before the records get their contract shape.
-  type Draft = { admin?: AdminRole & { assoc: string[]; rep: string | null }; teams: TeamMembership[] }
-  const drafts = new Map<string, Draft>(people.map((p) => [p.id, { teams: [] }]))
-  const draft = (p: StoredPerson) => drafts.get(p.id) ?? { teams: [] }
-
-  const makeAdmin = (p: StoredPerson, status: "active" | "former") => {
-    const rep = random() < 0.15 ? pick(REPS) : null
-    const assoc = random() < 0.2 ? sample(ASSOCIATIONS, random() < 0.3 ? 2 : 1) : []
-    const availableAsCapo = random() < 0.12
-    const since = randomDate("2021-09-01", "2026-06-30")
-    const endedOn = status === "former" ? randomDate("2026-09-20", "2026-10-10") : null
-    const endReason = status === "former" ? pick(["Graduated", "No longer has time", "Moved abroad"]) : null
-    draft(p).admin = {
-      status,
-      since,
-      endedOn,
-      endReason,
-      availableAsCapo,
-      capoOfReference: null,
-      capoScope: null,
-      assoc,
-      rep,
+  for (let n = 1; n <= 40; n++) {
+    const firstName = FIRST[n - 1] ?? "Persona"
+    const lastName = LAST[(n * 7) % LAST.length] ?? "Rossi"
+    const linked = LINKED.has(n)
+    const createdAt = `${addDays(now, -200 + n)}T09:00:00.000Z`
+    const linkedOn = linked ? addDays(now, n <= 6 ? -60 - n : n % 3 === 0 ? -(n % 25) : -40 - n) : null
+    const person: StoredPerson = {
+      id: `P-${pad(n)}`,
+      firstName,
+      lastName,
+      // P-0040 has no contact email, so it can't be invited.
+      contactEmail: n === 40 ? null : `${slug(firstName)}.${slug(lastName)}@example.org`,
+      phone: n % 3 === 0 ? `+39 3${pad(n * 37).slice(0, 2)} ${pad(n * 91)}${pad(n * 13).slice(0, 3)}` : null,
+      telegramUsername: n % 4 === 0 ? null : `${slug(firstName)}${slug(lastName)}`,
+      notes: n === 6 ? "Prefers to be contacted on Telegram." : null,
+      accountSub: linked ? `sub-${pad(n)}` : null,
+      linkMethod: linked ? (n === 27 ? "auth" : n % 2 ? "invite" : "manual") : null,
+      linkedOn,
+      linkedBy: linked ? (n === 27 ? "auth" : n % 2 ? `sub-${pad(n)}` : HR_SUB) : null,
+      invite: INVITED.has(n)
+        ? {
+            email: `${slug(firstName)}.${slug(lastName)}@example.org`,
+            sentOn: addDays(now, n === EXPIRED_INVITE ? -20 : -n % 10),
+            expiresOn: addDays(now, n === EXPIRED_INVITE ? -6 : 14 - (n % 10)),
+            sentBy: HR_SUB,
+          }
+        : null,
+      assignments: [],
+      activity: [
+        ...(linked && linkedOn
+          ? [
+              {
+                actor: n === 27 ? "auth" : n % 2 ? `sub-${pad(n)}` : HR_SUB,
+                text:
+                  n === 27
+                    ? "Created the record for the account's roles in PoliNetwork Auth"
+                    : `Linked account sub-${pad(n)} (${n % 2 ? "email invite" : "by hand"})`,
+                at: `${linkedOn}T10:00:00.000Z`,
+              },
+            ]
+          : []),
+        { actor: n === 27 ? "auth" : HR_SUB, text: "Created the record", at: createdAt },
+      ],
+      createdBy: n === 27 ? "auth" : HR_SUB,
+      createdAt,
+      updatedBy: HR_SUB,
+      updatedAt: createdAt,
     }
-  }
-  const teamFields = (team: TeamId, p: StoredPerson): TeamFields => {
-    const first = slug(p.profile.firstName)
-    const last = slug(p.profile.lastName)
-    if (team === "it")
-      return {
-        github: first + last.slice(0, 4),
-        areas: sample(["Frontend", "Backend", "Bot", "Infrastructure"], 1 + Math.floor(random() * 2)),
-      }
-    if (team === "design")
-      return {
-        tools: sample(
-          ["Figma", "Illustrator", "Photoshop", "After Effects", "InDesign", "Premiere"],
-          2 + Math.floor(random() * 2)
-        ),
-        portfolio: random() < 0.7 ? `behance.net/${first}${last}` : "",
-      }
-    if (team === "intl")
-      return {
-        languages: sample(
-          ["English", "Spanish", "French", "German", "Chinese", "Portuguese"],
-          1 + Math.floor(random() * 2)
-        ),
-      }
-    const focus =
-      team === "hr"
-        ? ["Recruiting", "Onboarding", "Census", "Wellbeing"]
-        : ["Partnerships", "Logistics", "Sponsorships", "Communication"]
-    return { focus: sample(focus, 1 + Math.floor(random() * 2)) }
-  }
-  const makeTeam = (
-    p: StoredPerson,
-    team: TeamId,
-    role: "member" | "lead" = "member",
-    since?: string,
-    fields?: TeamFields
-  ): TeamMembership => ({
-    team,
-    role,
-    since: since ?? randomDate("2023-01-10", "2026-09-30"),
-    endedOn: null,
-    endReason: null,
-    fields: fields ?? teamFields(team, p),
-  })
-
-  const generic = shuffle(people.filter((p) => !(p.id in KEYS)))
-  generic.slice(0, 96).forEach((p) => makeAdmin(p, "active"))
-  generic.slice(96, 103).forEach((p) => makeAdmin(p, "former"))
-  const slots: TeamId[] = [
-    "it",
-    "it",
-    "it",
-    "it",
-    "it",
-    "hr",
-    "hr",
-    "hr",
-    "design",
-    "design",
-    "design",
-    "design",
-    "design",
-    "design",
-    "intl",
-    "intl",
-    "events",
-    "events",
-    "events",
-    "events",
-  ]
-  ;[...generic.slice(18, 30), ...generic.slice(127, 135)].forEach((p, index) =>
-    draft(p).teams.push(makeTeam(p, slots[index]))
-  )
-  draft(generic[20]).teams.push(makeTeam(generic[20], "events"))
-  for (const [p, team] of [
-    [generic[135], "it"],
-    [generic[100], "design"],
-    [generic[40], "it"],
-    [generic[60], "events"],
-  ] as const) {
-    const membership = makeTeam(p, team, "member", randomDate("2023-02-01", "2024-12-01"))
-    membership.endedOn = randomDate("2026-01-10", "2026-09-30")
-    membership.endReason = pick(["Graduated", "No longer has time", "Moved to another team"])
-    draft(p).teams.push(membership)
+    people.push(person)
   }
 
-  const link = (p: StoredPerson) => {
-    const account: Account = {
-      status: "linked",
-      email: p.profile.personalEmail ?? "",
-      via: pick(["Telegram", "Google", "Microsoft 365"]),
-      linkedOn: randomDate("2026-02-01", "2026-10-10"),
-      how: pick(["Invite accepted", "Linked by Luca Ferri"]),
-    }
-    p.account = account
+  const byNumber = (n: number) => {
+    const person = people[n - 1]
+    if (!person) throw new Error(`No sample record ${n}`)
+    return person
   }
-  const invite = (p: StoredPerson, expired: boolean) => {
-    const sentOn = expired ? randomDate("2026-09-08", "2026-09-24") : randomDate("2026-09-30", "2026-10-13")
-    p.account = {
-      status: "invite",
-      email: p.profile.personalEmail ?? "",
-      sentOn,
-      expiresOn: addDays(sentOn, 14),
-      sentBy: pick(["Luca Ferri", "Marta Colombo"]),
+  const assign = (n: number, fields: Partial<StoredAssignment> & Pick<Assignment, "kind" | "since">) => {
+    const person = byNumber(n)
+    const assignment: StoredAssignment = {
+      id: `A-${pad(nextAssignment++)}`,
+      team: null,
+      teamRole: null,
+      capoScope: null,
+      capoOfReference: null,
+      fields: {},
+      endedOn: null,
+      endReason: null,
+      assignedBy: person.linkMethod === "auth" ? "auth" : HR_SUB,
+      change: "start",
+      status: person.accountSub ? "applied" : "pending",
+      refusal: null,
+      settlesAt: null,
+      ...fields,
     }
+    person.assignments.push(assignment)
+    return assignment
   }
-  ;[...generic.slice(0, 10), ...generic.slice(18, 30), ...generic.slice(103, 109), ...generic.slice(127, 132)].forEach(
-    link
-  )
-  ;[...generic.slice(10, 18), ...generic.slice(109, 113)].forEach((p) =>
-    invite(p, p === generic[11] || p === generic[110])
-  )
-
-  // Key people.
-  const keyAdmin = (
-    id: string,
-    since: string,
-    extra: Partial<AdminRole & { assoc: string[]; rep: string | null }> = {}
-  ) => {
-    const p = person(id)
-    makeAdmin(p, "active")
-    const admin = draft(p).admin
-    if (!admin) return
-    Object.assign(admin, { since, rep: null, assoc: [], availableAsCapo: false }, extra)
-  }
-  keyAdmin("P-0142", "2024-10-03", { availableAsCapo: true, rep: "Consiglio di Corso di Studio", assoc: ["Skyward"] })
-  keyAdmin("P-0098", "2022-09-20", { assoc: ["JEMP"] })
-  keyAdmin("P-0034", "2023-03-01")
-  keyAdmin("P-0115", "2025-09-25", { rep: "Consiglio degli Studenti" })
-  keyAdmin("P-0063", "2025-02-11")
-  keyAdmin("P-0021", "2023-10-12")
-  keyAdmin("P-0088", "2024-03-05")
-  keyAdmin("P-0076", "2026-03-02")
-  const chiara = person("P-0131")
-  makeAdmin(chiara, "former")
-  const chiaraAdmin = draft(chiara).admin
-  if (chiaraAdmin) Object.assign(chiaraAdmin, { since: "2022-10-01", endedOn: "2026-07-10", endReason: "Graduated" })
-  draft(chiara).teams.push({
-    ...makeTeam(chiara, "design", "member", "2023-01-15"),
-    endedOn: "2026-07-10",
-    endReason: "Graduated",
-  })
+  const ref = (n: number) => ({ id: byNumber(n).id, name: `${byNumber(n).firstName} ${byNumber(n).lastName}` })
 
-  draft(person("P-0034")).teams.push(
-    makeTeam(person("P-0034"), "it", "lead", "2023-02-10", {
-      github: "saragalli",
-      areas: ["Backend", "Infrastructure"],
+  for (const n of ADMINS) {
+    const capo = CAPOS.find((entry) => entry.admins.includes(n))?.capo
+    const admin = assign(n, {
+      kind: "admin",
+      since: addDays(now, -300 + n * 5),
+      capoOfReference: capo ? ref(capo) : null,
     })
-  )
-  draft(person("P-0142")).teams.push(
-    makeTeam(person("P-0142"), "it", "member", "2025-03-04", { github: "giuliarossi", areas: ["Frontend", "Bot"] })
-  )
-  draft(person("P-0115")).teams.push(
-    makeTeam(person("P-0115"), "it", "member", "2025-10-01", { github: "mconti", areas: ["Bot"] })
-  )
-  draft(person("P-0021")).teams.push(
-    makeTeam(person("P-0021"), "hr", "lead", "2024-01-15", { focus: ["Recruiting", "Onboarding"] })
-  )
-  draft(person("P-0045")).teams.push(
-    makeTeam(person("P-0045"), "design", "lead", "2024-03-01", {
-      tools: ["Figma", "Illustrator", "After Effects"],
-      portfolio: "behance.net/alessiafontana",
-    })
-  )
-  draft(person("P-0052")).teams.push(
-    makeTeam(person("P-0052"), "intl", "lead", "2024-11-05", { languages: ["English", "Spanish"] })
-  )
-  draft(person("P-0007")).teams.push(
-    makeTeam(person("P-0007"), "events", "lead", "2022-02-01", { focus: ["Partnerships", "Sponsorships"] })
-  )
-  for (const id of ["P-0098", "P-0034", "P-0115", "P-0063", "P-0007", "P-0021", "P-0045", "P-0052"]) link(person(id))
-  const davideAccount = person("P-0098").account
-  if (davideAccount.status === "linked") davideAccount.how = "Invite accepted"
-  person("P-0142").account = {
-    status: "invite",
-    email: "giulia.rossi.02@gmail.com",
-    sentOn: "2026-10-06",
-    expiresOn: "2026-10-20",
-    sentBy: "Luca Ferri",
-  }
-  invite(person("P-0076"), true)
-
-  // Capo Admins: Davide for Informatica, the first generic active admin of every other family.
-  const davideAdmin = draft(person("P-0098")).admin
-  if (davideAdmin) davideAdmin.capoScope = FAMILIES.inf.scope
-  const capoOf = new Map<FamilyId, StoredPerson>([["inf", person("P-0098")]])
-  for (const family of FAMILY_IDS.slice(1)) {
-    const capo = generic.find(
-      (p) => p.family === family && draft(p).admin?.status === "active" && !draft(p).admin?.capoScope
-    )
-    const capoAdmin = capo && draft(capo).admin
-    if (capo && capoAdmin) {
-      capoAdmin.capoScope = FAMILIES[family].scope
-      capoOf.set(family, capo)
-    }
-  }
-  for (const p of people) {
-    const admin = draft(p).admin
-    const capo = capoOf.get(p.family)
-    if (admin && capo && capo !== p) {
-      admin.capoOfReference = { id: capo.id, name: `${capo.profile.firstName} ${capo.profile.lastName}` }
-    }
+    if (n === WAITING.admin) admin.status = "sent"
   }
+  CAPOS.forEach(({ capo, scope }, index) =>
+    assign(capo, { kind: "capo", since: addDays(now, -120 + index * 10), capoScope: scope })
+  )
+  // A former admin, and an admin role Auth refused to give (the record shows why; nobody assigned it again).
+  assign(1, { kind: "admin", since: addDays(now, -500), endedOn: addDays(now, -200), endReason: "Graduated" })
+  assign(12, {
+    kind: "capo",
+    since: addDays(now, -30),
+    capoScope: "Ingegneria Meccanica",
+    endedOn: addDays(now, -30),
+    endReason: "Refused by PoliNetwork Auth",
+    status: "refused",
+    refusal: REFUSAL,
+  })
 
-  // Admin and team roles take their contract shape, then consents from the first day of any role.
-  for (const p of people) {
-    const d = draft(p)
-    if (d.admin) {
-      const { assoc, rep, ...admin } = d.admin
-      p.admin = admin
-      p.profile.otherAssociations = assoc
-      p.profile.studentRepresentative = rep
-    }
-    p.teams = d.teams
-    const start = [p.admin?.since, ...p.teams.map((team) => team.since)]
-      .filter((date): date is string => !!date)
-      .sort()[0]
-    if (start) {
-      const roll = random()
-      p.consents = {
-        privacy: { version: start >= "2025-09-01" ? "3" : "2", acceptedOn: start },
-        photo: roll < 0.8 ? { status: "granted", on: start } : roll < 0.95 ? { status: "denied", on: start } : null,
-      }
+  for (const team of TEAM_IDS) {
+    const roster: { lead: number | null; members: number[]; former: number[] } = TEAMS_OF[team]
+    const since = (n: number) => addDays(now, -400 + n * 9)
+    if (roster.lead) assign(roster.lead, { kind: "team", team, teamRole: "lead", since: since(roster.lead) })
+    for (const n of roster.members) {
+      const assignment = assign(n, { kind: "team", team, teamRole: "member", since: since(n), fields: FIELDS[team](n) })
+      if (n === WAITING.teamEnd)
+        Object.assign(assignment, { endedOn: now, endReason: "Moved to another team", change: "end", status: "sent" })
     }
+    for (const n of roster.former)
+      assign(n, {
+        kind: "team",
+        team,
+        teamRole: "member",
+        since: since(n),
+        endedOn: addDays(now, -20),
+        endReason: "No longer has time",
+        change: "end",
+        fields: FIELDS[team](n),
+      })
   }
+  // Auth refused to end this membership: the role is still held, and the record says why.
+  const refusedEnd = byNumber(22).assignments.find((assignment) => assignment.team === "it")
+  if (refusedEnd) Object.assign(refusedEnd, { change: "end", status: "refused", refusal: REFUSAL })
 
-  const giulia = person("P-0142")
-  giulia.consents = {
-    privacy: { version: "3", acceptedOn: "2026-09-21" },
-    photo: { status: "granted", on: "2026-09-21" },
-  }
-  giulia.notes = "Strong on the bot codebase; Sara suggests her for IT co-lead next year."
-  giulia.activity = [
-    { actor: "Luca Ferri", text: "sent an invite to giulia.rossi.02@gmail.com", at: "2026-10-06T18:42:00+02:00" },
-    { actor: "Sara Galli", text: "added Giulia to IT as Member", at: "2025-03-04T16:20:00+01:00" },
+  const directory: DirectoryAccount[] = [
+    ...people.flatMap((person) =>
+      person.accountSub
+        ? [{ sub: person.accountSub, name: `${person.firstName} ${person.lastName}`, email: accountEmail(person) }]
+        : []
+    ),
+    // Accounts nobody linked yet: some belong to people on the register, under another address.
+    { sub: "sub-0101", name: "Sara Colombo", email: "sara.c.2003@gmail.com" },
+    { sub: "sub-0102", name: "Davide Gallo", email: "davide.gallo@mail.polimi.it" },
+    { sub: "sub-0103", name: "Marta Fabbri", email: "marta.fabbri@polinetwork.org" },
+    { sub: "sub-0104", name: "Luca Ferrari", email: "lferrari99@gmail.com" },
+    { sub: "sub-0105", name: "Ospite Esterno", email: "guest.account@gmail.com" },
   ]
-  person("P-0088").censusTelegram = "marco_bianchi"
 
-  return { people, byId }
+  return { people, byId: new Map(people.map((person) => [person.id, person])), directory, nextAssignment }
+}
+
+/** The sign-in a linked record uses: a PoliNetwork account for some, a personal Google account for others. */
+function accountEmail(person: StoredPerson) {
+  const local = `${slug(person.firstName)}.${slug(person.lastName)}`
+  return Number(person.id.slice(2)) % 2 ? `${local}@polinetwork.org` : `${local}@gmail.com`
 }
diff --git a/src/features/people/people.functions.ts b/src/features/people/people.functions.ts
index 9cfa20d..6db23ab 100644
--- a/src/features/people/people.functions.ts
+++ b/src/features/people/people.functions.ts
@@ -1,10 +1,10 @@
 import { createServerFn } from "@tanstack/react-start"
 import { z } from "zod"
 
-import { peopleReadMiddleware, peopleSelfMiddleware, peopleWriteMiddleware } from "@/server/auth.middleware"
+import { peopleReadMiddleware, peopleSelfMiddleware } from "@/server/auth.middleware"
 
 import { peopleApi } from "./people.api.server"
-import { personIdSchema, searchAccountsInputSchema } from "./people.contract"
+import { personIdSchema } from "./people.contract"
 
 /** The Capo Admin scope and led teams on the signed-in person's record; they open Capo Admin and their team page. */
 export const getMyPeopleRoles = createServerFn({ method: "GET" })
@@ -20,12 +20,15 @@ export const getPerson = createServerFn({ method: "GET" })
   .validator(z.object({ id: personIdSchema }))
   .handler(async ({ data, context }) => (await peopleApi(context)).getPerson(data.id))
 
+/** People › Admins: current admins with their Capo Admin of reference, and the Capo Admins with their admins. */
+export const getAdminsAndCapos = createServerFn({ method: "GET" })
+  .middleware([peopleReadMiddleware])
+  .handler(async ({ context }) => {
+    const api = await peopleApi(context)
+    const [admins, capos] = await Promise.all([api.listAdmins(), api.listCapos()])
+    return { admins, capos }
+  })
+
 export const getPendingInvites = createServerFn({ method: "GET" })
   .middleware([peopleReadMiddleware])
   .handler(async ({ context }) => (await peopleApi(context)).listInvites())
-
-/** Sign-in accounts that could be this person's, with why they match. Needed only to link, hence the write scope. */
-export const searchPeopleAccounts = createServerFn({ method: "GET" })
-  .middleware([peopleWriteMiddleware])
-  .validator(searchAccountsInputSchema)
-  .handler(async ({ data, context }) => (await peopleApi(context)).searchAccounts(data))
diff --git a/src/features/people/person-dialog.tsx b/src/features/people/person-dialog.tsx
index 601c405..828487c 100644
--- a/src/features/people/person-dialog.tsx
+++ b/src/features/people/person-dialog.tsx
@@ -3,66 +3,84 @@ import { useServerFn } from "@tanstack/react-start"
 import { type ChangeEvent, useState } from "react"
 
 import { checkboxControl, fieldControl, fieldHintId, FormDialog, FormField, SelectField } from "@/components/primitives"
+import { useCan } from "@/components/shell"
 import { Checkbox } from "@/components/ui/checkbox"
 import { Input } from "@/components/ui/input"
 import { cn } from "@/lib/utils"
 
-import { yearOf } from "./people-format"
 import { errorMessage, useRefreshAfter } from "./people-hooks"
 import { createPerson, updatePerson } from "./people-write.functions"
-import { CAMPUSES, type Campus, COURSES, type PersonRow, TELEGRAM_USERNAME_PATTERN, YEARS } from "./people.contract"
-
-type Year = (typeof YEARS)[number]
+import {
+  type PersonRow,
+  TEAM_IDS,
+  TELEGRAM_USERNAME_PATTERN,
+  type TeamId,
+  type TeamRole,
+  type TeamSummary,
+} from "./people.contract"
 
 const SAVE_ERROR = "Couldn't save the person. Check the values and try again."
 const EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
+const NO_TEAM = "none"
 
 function validTelegram(value: string) {
   return value.trim() === "" || TELEGRAM_USERNAME_PATTERN.test(value.trim())
 }
 
-/** Add a person, or edit an existing record's profile (`person`). */
+function validEmail(value: string) {
+  return value.trim() === "" || EMAIL_PATTERN.test(value.trim())
+}
+
+/**
+ * Add a person, or edit a record's name and contacts (`person`). Only the name is required. A new record can start
+ * with roles (`teams` lists the teams to offer); they stay pending until the record is linked to an account.
+ */
 export function PersonDialog({
   open,
   onOpenChange,
   person,
+  teams = [],
 }: {
   open: boolean
   onOpenChange: (open: boolean) => void
   person?: PersonRow
+  teams?: readonly TeamSummary[]
 }) {
   const create = useServerFn(createPerson)
   const update = useServerFn(updatePerson)
   const navigate = useNavigate()
   const refresh = useRefreshAfter()
+  const canAppoint = useCan("people:appoint")
   const initial = {
-    firstName: person?.profile.firstName ?? "",
-    lastName: person?.profile.lastName ?? "",
-    personalEmail: person?.profile.personalEmail ?? "",
-    phone: person?.profile.phone ?? "",
-    telegramUsername: person?.profile.telegramUsername ? `@${person.profile.telegramUsername}` : "",
-    course: person?.profile.course ?? "",
-    year: person ? yearOf(person.profile.year) : null,
-    campus: person?.profile.campus ?? null,
+    firstName: person?.firstName ?? "",
+    lastName: person?.lastName ?? "",
+    contactEmail: person?.contactEmail ?? "",
+    phone: person?.phone ?? "",
+    telegramUsername: person?.telegramUsername ? `@${person.telegramUsername}` : "",
   }
   const [values, setValues] = useState(initial)
   const [admin, setAdmin] = useState(false)
+  const [capo, setCapo] = useState(false)
+  const [capoScope, setCapoScope] = useState("")
+  const [teamRoles, setTeamRoles] = useState<Partial<Record<TeamId, TeamRole>>>({})
   const [submitted, setSubmitted] = useState(false)
 
-  const errors: Partial<Record<keyof typeof initial, string>> = submitted
+  const errors: Partial<Record<keyof typeof initial | "capoScope", string>> = submitted
     ? {
         firstName: values.firstName.trim() ? undefined : "Enter a first name.",
         lastName: values.lastName.trim() ? undefined : "Enter a last name.",
-        personalEmail: EMAIL_PATTERN.test(values.personalEmail.trim()) ? undefined : "Enter a valid email address.",
+        contactEmail: validEmail(values.contactEmail) ? undefined : "Enter a valid email address.",
         telegramUsername: validTelegram(values.telegramUsername)
           ? undefined
           : "Enter 5–32 letters, digits or underscores.",
-        course: values.course.trim() ? undefined : "Choose a course.",
-        year: values.year ? undefined : "Choose a year.",
-        campus: values.campus ? undefined : "Choose a campus.",
+        capoScope: capo && !capoScope.trim() ? "Enter what they coordinate." : undefined,
       }
     : {}
-  const dirty = JSON.stringify(values) !== JSON.stringify(initial) || admin
+  const chosenTeams = TEAM_IDS.flatMap((team) => {
+    const role = teamRoles[team]
+    return role ? [{ team, role }] : []
+  })
+  const dirty = JSON.stringify(values) !== JSON.stringify(initial) || admin || capo || chosenTeams.length > 0
 
   function set<K extends keyof typeof values>(key: K, value: (typeof values)[K]) {
     setValues((current) => ({ ...current, [key]: value }))
@@ -70,47 +88,59 @@ export function PersonDialog({
 
   async function submit() {
     setSubmitted(true)
-    const { year, campus } = values
     if (
       !values.firstName.trim() ||
       !values.lastName.trim() ||
-      !EMAIL_PATTERN.test(values.personalEmail.trim()) ||
+      !validEmail(values.contactEmail) ||
       !validTelegram(values.telegramUsername) ||
-      !values.course.trim() ||
-      !year ||
-      !campus
+      (capo && !capoScope.trim())
     ) {
       return
     }
     const fields = {
       firstName: values.firstName.trim(),
       lastName: values.lastName.trim(),
-      personalEmail: values.personalEmail.trim(),
+      contactEmail: values.contactEmail.trim(),
       phone: values.phone.trim(),
       telegramUsername: values.telegramUsername.trim(),
-      course: values.course.trim(),
-      year,
-      campus,
     }
-    try {
-      if (person) {
+    if (person) {
+      try {
         await update({ data: { ...fields, id: person.id } })
-      } else {
-        const created = await create({ data: { ...fields, admin } })
-        await refresh("Person added.")
-        onOpenChange(false)
-        await navigate({ to: "/dashboard/people/$personId", params: { personId: created.id } })
-        return
+      } catch (caught) {
+        console.error(caught)
+        throw new Error(errorMessage(caught, SAVE_ERROR), { cause: caught })
       }
+      await refresh("Record saved.")
+      onOpenChange(false)
+      return
+    }
+    let created: Awaited<ReturnType<typeof create>>
+    try {
+      created = await create({
+        data: {
+          ...fields,
+          admin: admin || capo,
+          capoScope: capo ? capoScope.trim() : null,
+          teams: chosenTeams,
+        },
+      })
     } catch (caught) {
       console.error(caught)
       throw new Error(errorMessage(caught, SAVE_ERROR), { cause: caught })
     }
-    await refresh("Profile saved.")
     onOpenChange(false)
+    await navigate({ to: "/dashboard/people/$personId", params: { personId: created.id } })
+    // The record exists either way: a refused role is reported, not a failed save.
+    if (created.refused.length) {
+      const list = created.refused.map((entry) => `${entry.role}: ${entry.message}`).join(" · ")
+      await refresh(`Person added, but not every role was given. ${list}`, "warning")
+    } else {
+      await refresh("Person added.")
+    }
   }
 
-  const text = (key: "firstName" | "lastName" | "personalEmail" | "phone" | "telegramUsername", id: string) => ({
+  const text = (key: keyof typeof initial, id: string) => ({
     id,
     value: values[key],
     onChange: (event: ChangeEvent<HTMLInputElement>) => set(key, event.target.value),
@@ -118,20 +148,23 @@ export function PersonDialog({
     "aria-describedby": fieldHintId(id),
   })
 
+  const leadOpen = (team: TeamSummary) => canAppoint && team.assignable.lead && !team.lead
+  const assignableTeams = teams.filter((team) => team.assignable.member || leadOpen(team))
+
   return (
     <FormDialog
       open={open}
       onOpenChange={onOpenChange}
       size="lg"
-      title={person ? "Edit profile" : "Add person"}
+      title={person ? "Edit record" : "Add person"}
       description={
         person
           ? "Changes are saved to the record and shown in its activity."
-          : "Creates a record. The person doesn't need an account; you can invite them later."
+          : "Only the name is required. The person doesn't need an account: their roles wait until you link one or they accept an invite."
       }
       noun="person"
       dirty={dirty}
-      submitLabel={person ? "Save profile" : "Add person"}
+      submitLabel={person ? "Save" : "Add person"}
       onSubmit={submit}
     >
       <div className="grid grid-cols-1 gap-4 shell:grid-cols-2">
@@ -141,8 +174,14 @@ export function PersonDialog({
         <FormField label="Last name" htmlFor="person-last" error={errors.lastName}>
           <Input {...text("lastName", "person-last")} autoComplete="off" className={fieldControl} />
         </FormField>
-        <FormField label="Personal email" htmlFor="person-email" error={errors.personalEmail}>
-          <Input {...text("personalEmail", "person-email")} type="email" autoComplete="off" className={fieldControl} />
+        <FormField
+          label="Contact email"
+          htmlFor="person-email"
+          optional
+          hint="Where invites go. It doesn't have to be the address they sign in with."
+          error={errors.contactEmail}
+        >
+          <Input {...text("contactEmail", "person-email")} type="email" autoComplete="off" className={fieldControl} />
         </FormField>
         <FormField label="Phone" htmlFor="person-phone" optional>
           <Input {...text("phone", "person-phone")} type="tel" autoComplete="off" className={fieldControl} />
@@ -151,7 +190,7 @@ export function PersonDialog({
           label="Telegram username"
           htmlFor="person-telegram"
           optional
-          hint="Used to match the Telegram user the bot already knows."
+          hint="For contacting them. It isn't used to link an account."
           error={errors.telegramUsername}
         >
           <Input
@@ -161,49 +200,80 @@ export function PersonDialog({
             className={cn(fieldControl, "font-mono")}
           />
         </FormField>
-        <FormField label="Course" htmlFor="person-course" error={errors.course}>
-          <SelectField
-            id="person-course"
-            value={values.course || null}
-            options={COURSES.map((course) => ({ value: course, label: course }))}
-            onChange={(course) => set("course", course)}
-            placeholder="Choose a course"
-            invalid={!!errors.course}
-          />
-        </FormField>
-        <FormField label="Year" htmlFor="person-year" error={errors.year}>
-          <SelectField<Year>
-            id="person-year"
-            value={values.year}
-            options={YEARS.map((year) => ({ value: year, label: year }))}
-            onChange={(year) => set("year", year)}
-            placeholder="Choose a year"
-            invalid={!!errors.year}
-          />
-        </FormField>
-        <FormField label="Campus" htmlFor="person-campus" error={errors.campus}>
-          <SelectField<Campus>
-            id="person-campus"
-            value={values.campus}
-            options={CAMPUSES.map((campus) => ({ value: campus, label: campus }))}
-            onChange={(campus) => set("campus", campus)}
-            placeholder="Choose a campus"
-            invalid={!!errors.campus}
-          />
-        </FormField>
       </div>
       {person ? null : (
-        <label className="mt-4 flex items-start gap-2.5 text-[14px]">
-          <Checkbox
-            checked={admin}
-            onCheckedChange={(checked) => setAdmin(checked === true)}
-            className={checkboxControl}
-          />
-          <span className="flex flex-col gap-0.5">
-            <span className="font-medium">Admin of Telegram groups</span>
-            <span className="text-xs text-(--pn-fg-muted)">Teams are added from Teams.</span>
-          </span>
-        </label>
+        <fieldset className="mt-6 flex flex-col gap-4">
+          <legend className="mb-3 text-[14px] font-medium">
+            Roles <span className="font-normal text-(--pn-fg-muted)">(optional)</span>
+          </legend>
+          <label className="flex items-start gap-2.5 text-[14px]">
+            <Checkbox
+              checked={admin || capo}
+              disabled={capo}
+              onCheckedChange={(checked) => setAdmin(checked === true)}
+              className={checkboxControl}
+            />
+            <span className="flex flex-col gap-0.5">
+              <span className="font-medium">Admin</span>
+              <span className="text-xs text-(--pn-fg-muted)">Administers Telegram groups.</span>
+            </span>
+          </label>
+          {canAppoint ? (
+            <div className="flex flex-col gap-3">
+              <label className="flex items-start gap-2.5 text-[14px]">
+                <Checkbox
+                  checked={capo}
+                  onCheckedChange={(checked) => setCapo(checked === true)}
+                  className={checkboxControl}
+                />
+                <span className="flex flex-col gap-0.5">
+                  <span className="font-medium">Capo Admin</span>
+                  <span className="text-xs text-(--pn-fg-muted)">Coordinates admins; makes them an admin too.</span>
+                </span>
+              </label>
+              {capo ? (
+                <FormField label="Capo Admin of" htmlFor="person-capo-scope" error={errors.capoScope}>
+                  <Input
+                    id="person-capo-scope"
+                    value={capoScope}
+                    onChange={(event) => setCapoScope(event.target.value)}
+                    maxLength={120}
+                    placeholder="e.g. Ingegneria Informatica"
+                    autoComplete="off"
+                    aria-invalid={errors.capoScope ? true : undefined}
+                    aria-describedby={fieldHintId("person-capo-scope")}
+                    className={fieldControl}
+                  />
+                </FormField>
+              ) : null}
+            </div>
+          ) : null}
+          {assignableTeams.length ? (
+            <div className="grid grid-cols-1 gap-3 shell:grid-cols-2">
+              {assignableTeams.map((team) => (
+                <FormField key={team.id} label={team.name} htmlFor={`person-team-${team.id}`} optional>
+                  <SelectField<TeamRole | typeof NO_TEAM>
+                    id={`person-team-${team.id}`}
+                    value={teamRoles[team.id] ?? NO_TEAM}
+                    options={[
+                      { value: NO_TEAM, label: "Not in the team" },
+                      ...(team.assignable.member ? [{ value: "member" as const, label: "Member" }] : []),
+                      ...(leadOpen(team) ? [{ value: "lead" as const, label: "Lead" }] : []),
+                    ]}
+                    onChange={(role) =>
+                      setTeamRoles((current) => {
+                        const next = { ...current }
+                        if (role === NO_TEAM) delete next[team.id]
+                        else next[team.id] = role
+                        return next
+                      })
+                    }
+                  />
+                </FormField>
+              ))}
+            </div>
+          ) : null}
+        </fieldset>
       )}
     </FormDialog>
   )
diff --git a/src/features/people/person-page.tsx b/src/features/people/person-page.tsx
index 22f434d..97e307d 100644
--- a/src/features/people/person-page.tsx
+++ b/src/features/people/person-page.tsx
@@ -1,21 +1,19 @@
 import { Link } from "@tanstack/react-router"
-import { useServerFn } from "@tanstack/react-start"
 import {
-  Camera,
   Crown,
-  FileText,
+  History,
   Link2,
   Mail,
   NotebookPen,
   Pencil,
   RefreshCw,
+  ShieldUser,
   Unlink,
   UserMinus,
   UserPlus,
   UserRoundCog,
   Users,
 } from "lucide-react"
-import { useState } from "react"
 
 import {
   buttonMotion,
@@ -23,7 +21,6 @@ import {
   InlineAlert,
   KeyValueList,
   type KeyValueItem,
-  LoadingButton,
   PlatformGlyph,
   RecordHeader,
   SectionCard,
@@ -31,122 +28,241 @@ import {
   StatusBadge,
   Unset,
 } from "@/components/primitives"
-import { appToast, PageBar, PageContent, useCan } from "@/components/shell"
+import { PageBar, PageContent, useCan } from "@/components/shell"
 import { Button } from "@/components/ui/button"
 import { formatDateTime } from "@/lib/format"
 
 import { type AccountAction, AccountActionDialog } from "./account-action-dialog"
-import { CapoOfReferenceDialog, CapoScopeDialog, EndAdminDialog, EndCapoDialog } from "./admin-dialogs"
-import { LinkAccountDialog } from "./link-account-dialog"
+import {
+  AppointCapoDialog,
+  AssignAdminDialog,
+  CapoOfReferenceDialog,
+  CapoScopeDialog,
+  EndAdminDialog,
+  EndCapoDialog,
+} from "./admin-dialogs"
+import { LinkAccountDialog, UnlinkAccountDialog } from "./link-account-dialog"
 import { NotesDialog } from "./notes-dialog"
 import {
   ACCOUNT_STATUS,
-  activeTeams,
+  actorName,
+  assignmentLabel,
+  currentAdmin,
+  currentCapo,
+  currentTeams,
   formatDay,
   hasNoRoles,
   isExpired,
+  isTeamAssignment,
+  LINK_METHOD,
+  openAssignments,
+  openRefusals,
   personName,
-  PHOTO_CONSENT,
   roleLabels,
   teamName,
-  yearOf,
+  type TeamAssignment,
+  waitingForAuth,
 } from "./people-format"
-import { errorMessage, useDialog, useDialogState, useRefreshAfter } from "./people-hooks"
-import { ActionMenu, PersonAvatar, Row, RowIcon, Rows, StateBadge } from "./people-ui"
-import { updatePerson } from "./people-write.functions"
-import { type PersonRecord, TEAM_IDS, type TeamMembership, teamFields } from "./people.contract"
+import { useDialog, useDialogState } from "./people-hooks"
+import {
+  ActionMenu,
+  AssignmentBadge,
+  type MenuAction,
+  PersonAvatar,
+  RefusalText,
+  Row,
+  RowIcon,
+  Rows,
+  StateBadge,
+} from "./people-ui"
+import {
+  type Assignment,
+  type PersonRecord,
+  type PersonRow,
+  TEAM_IDS,
+  teamFields,
+  type TeamSummary,
+} from "./people.contract"
 import { PersonDialog } from "./person-dialog"
 import { AddToTeamDialog, EditTeamFieldsDialog, EndTeamMembershipDialog, type TeamMemberTarget } from "./team-dialogs"
 
-type AdminDialogKind = "end" | "capoRef" | "capoScope" | "endCapo"
+type RoleDialog =
+  | { kind: "assignAdmin" | "endAdmin" | "capoRef" | "appointCapo" | "capoScope" | "endCapo" }
+  | { kind: "teamFields" | "endTeam"; target: TeamMemberTarget }
 
 const BACK = { label: "people", link: { to: "/dashboard/people" } } as const
 
-/** People › {name}: the whole record, its discrepancies and its history. */
-export function PersonPage({ person }: { person: PersonRecord }) {
+const KIND_ICON = { admin: ShieldUser, capo: Crown, team: Users }
+
+/** "Since 6 Oct 2026", or when and why it ended. */
+function assignmentMeta(assignment: Assignment) {
+  // A start Auth refused never took effect: its end date and reason only repeat the refusal.
+  if (assignment.status === "refused" && assignment.change === "start") return `Assigned ${formatDay(assignment.since)}`
+  const parts = [
+    assignment.endedOn && assignment.status !== "sent"
+      ? `${formatDay(assignment.since)} – ${formatDay(assignment.endedOn)}`
+      : `Since ${formatDay(assignment.since)}`,
+  ]
+  if (assignment.endReason) parts.push(assignment.endReason)
+  return parts.join(" · ")
+}
+
+function TeamFieldValues({ assignment }: { assignment: TeamAssignment }) {
+  const fields = teamFields(assignment.team)
+  if (!fields.length) return null
+  return (
+    <span className="flex flex-wrap gap-x-3 gap-y-1">
+      {fields.map((field) => {
+        const value = assignment.fields[field.key]
+        const text = Array.isArray(value) ? value.join(", ") : value
+        return (
+          <span key={field.key}>
+            <span className="text-(--pn-fg-muted)">{field.label} </span>
+            {text ? <span className={field.mono ? "font-mono" : undefined}>{text}</span> : <Unset />}
+          </span>
+        )
+      })}
+    </span>
+  )
+}
+
+/** People › {name}: the record, each role and where it stands with Auth, the account, and the history. */
+export function PersonPage({
+  person,
+  people,
+  teams: teamSummaries,
+}: {
+  person: PersonRecord
+  people: readonly PersonRow[]
+  teams: readonly TeamSummary[]
+}) {
   const canWrite = useCan("people:write")
   const canRead = useCan("people:read")
   const canAppoint = useCan("people:appoint")
-  const update = useServerFn(updatePerson)
-  const refresh = useRefreshAfter()
+  const canLink = useCan("people:link")
   const name = personName(person)
+  const linked = person.account.status === "linked"
   const archived = hasNoRoles(person)
   const roles = roleLabels(person)
-  const { profile, admin, account } = person
-  const adminTarget = { personId: person.id, name }
+  const admin = currentAdmin(person)
+  const capo = currentCapo(person)
+  const teams = currentTeams(person)
+  const open = openAssignments(person)
+  const openIds = new Set(open.map((assignment) => assignment.id))
+  const history = person.assignments.filter((assignment) => !openIds.has(assignment.id))
+  const refusals = openRefusals(person)
+  const waiting = waitingForAuth(person)
+  const pending = person.assignments.some((a) => a.endedOn === null && a.status === "pending")
+  const target = { personId: person.id, name }
+  const option = { id: person.id, name, linked }
+  const { account } = person
 
   const edit = useDialogState()
   const notes = useDialogState()
   const link = useDialogState()
+  const unlink = useDialogState()
   const addTeam = useDialogState()
   const accountDialog = useDialog<AccountAction>()
-  const adminDialog = useDialog<AdminDialogKind>()
-  const teamDialog = useDialog<{ kind: "fields" | "end"; target: TeamMemberTarget }>()
-  const [applyingTelegram, setApplyingTelegram] = useState(false)
+  const roleDialog = useDialog<RoleDialog>()
 
-  function openTeam(kind: "fields" | "end", membership: TeamMembership) {
-    teamDialog.show({ kind, target: { personId: person.id, name, team: membership.team, fields: membership.fields } })
+  function teamTarget(assignment: TeamAssignment): TeamMemberTarget {
+    return { personId: person.id, name, team: assignment.team, fields: assignment.fields, linked }
+  }
+
+  /**
+   * The actions on one current role. While a change waits for Auth, only those that stay in People (Capo Admin of
+   * reference, scope, team fields): the backend refuses another role change until Auth answers.
+   */
+  function roleActions(assignment: Assignment): (MenuAction | false)[] {
+    if (assignment.endedOn !== null) return []
+    if (assignment.kind === "admin")
+      return [
+        canWrite && {
+          label: "Capo Admin of reference",
+          icon: UserRoundCog,
+          onClick: () => roleDialog.show({ kind: "capoRef" }),
+        },
+        canAppoint &&
+          !capo &&
+          !waiting && {
+            label: "Appoint as Capo Admin",
+            icon: Crown,
+            onClick: () => roleDialog.show({ kind: "appointCapo" }),
+          },
+        // The backend ends the Capo Admin role first: offering it here would only fail.
+        canWrite &&
+          !capo &&
+          !waiting && {
+            label: "End admin role",
+            icon: UserMinus,
+            destructive: true,
+            onClick: () => roleDialog.show({ kind: "endAdmin" }),
+          },
+      ]
+    if (assignment.kind === "capo")
+      return [
+        canAppoint && { label: "Change scope", icon: Pencil, onClick: () => roleDialog.show({ kind: "capoScope" }) },
+        canAppoint &&
+          !waiting && {
+            label: "End Capo Admin role",
+            icon: Crown,
+            destructive: true,
+            onClick: () => roleDialog.show({ kind: "endCapo" }),
+          },
+      ]
+    if (!isTeamAssignment(assignment)) return []
+    return [
+      canWrite && {
+        label: "Edit team fields",
+        ariaLabel: `Edit the ${teamName(assignment.team)} team fields`,
+        icon: Pencil,
+        onClick: () => roleDialog.show({ kind: "teamFields", target: teamTarget(assignment) }),
+      },
+      (assignment.teamRole === "lead" ? canAppoint : canWrite) &&
+        !waiting && {
+          label: "End membership",
+          ariaLabel: `End the ${teamName(assignment.team)} membership`,
+          icon: UserMinus,
+          destructive: true,
+          onClick: () => roleDialog.show({ kind: "endTeam", target: teamTarget(assignment) }),
+        },
+    ]
   }
 
   function openAccount(kind: AccountAction["kind"], email: string) {
     accountDialog.show({ kind, personId: person.id, name, email })
   }
 
-  async function applyCensusTelegram(username: string) {
-    setApplyingTelegram(true)
-    try {
-      await update({
-        data: {
-          id: person.id,
-          firstName: profile.firstName,
-          lastName: profile.lastName,
-          personalEmail: profile.personalEmail ?? "",
-          phone: profile.phone ?? "",
-          telegramUsername: username,
-          course: profile.course,
-          year: yearOf(profile.year),
-          campus: profile.campus,
-        },
-      })
-    } catch (caught) {
-      console.error(caught)
-      appToast.error(errorMessage(caught, "Couldn't update the Telegram username."))
-      return
-    } finally {
-      setApplyingTelegram(false)
-    }
-    await refresh("Telegram username updated.")
-  }
+  const addActions: (MenuAction | false)[] = waiting
+    ? []
+    : [
+        canWrite &&
+          !admin && { label: "Make admin", icon: ShieldUser, onClick: () => roleDialog.show({ kind: "assignAdmin" }) },
+        canAppoint &&
+          admin !== null &&
+          !capo && {
+            label: "Appoint as Capo Admin",
+            icon: Crown,
+            onClick: () => roleDialog.show({ kind: "appointCapo" }),
+          },
+        canWrite && teams.length < TEAM_IDS.length && { label: "Add to team", icon: UserPlus, onClick: addTeam.show },
+      ]
 
-  const profileItems: KeyValueItem[] = [
-    ...(profile.personalEmail !== null
-      ? [{ key: "Personal email", value: <span className="[overflow-wrap:anywhere]">{profile.personalEmail}</span> }]
-      : []),
-    ...(profile.phone !== null ? [{ key: "Phone", value: profile.phone }] : []),
+  const contactItems: KeyValueItem[] = [
     {
-      key: "Telegram",
-      value: profile.telegramUsername ? (
-        <span className="inline-flex flex-wrap items-center gap-1.5">
-          <PlatformGlyph platform="tg" className="size-3.5" />
-          <span className="font-mono">@{profile.telegramUsername}</span>
-          {profile.telegramId ? <span className="font-mono text-(--pn-fg-muted)">· {profile.telegramId}</span> : null}
-        </span>
-      ) : null,
+      key: "Contact email",
+      value: person.contactEmail ? <span className="[overflow-wrap:anywhere]">{person.contactEmail}</span> : null,
     },
-    { key: "Course", value: profile.course },
-    { key: "Year", value: profile.year },
-    { key: "Campus", value: <Chip>{profile.campus}</Chip> },
+    { key: "Phone", value: person.phone },
     {
-      key: "Other associations",
-      value: profile.otherAssociations.length ? (
-        <span className="flex flex-wrap gap-1.5">
-          {profile.otherAssociations.map((association) => (
-            <Chip key={association}>{association}</Chip>
-          ))}
+      key: "Telegram",
+      value: person.telegramUsername ? (
+        <span className="inline-flex items-center gap-1.5">
+          <PlatformGlyph platform="tg" className="size-3.5" />
+          <span className="font-mono">@{person.telegramUsername}</span>
         </span>
       ) : null,
     },
-    { key: "Student representative", value: profile.studentRepresentative },
   ]
 
   return (
@@ -158,58 +274,113 @@ export function PersonPage({ person }: { person: PersonRecord }) {
             title={name}
             avatar={<PersonAvatar name={name} size={64} muted={archived} />}
             badge={<StateBadge state={ACCOUNT_STATUS[account.status]} />}
-            meta={
-              <span className="flex flex-wrap items-center gap-x-1.5">
-                <span className="font-mono">{person.id}</span>
-                <span aria-hidden>·</span>
-                <span>{profile.course}</span>
-                <span aria-hidden>·</span>
-                <span>{profile.year}</span>
-                <span aria-hidden>·</span>
-                <span>{profile.campus}</span>
-              </span>
-            }
+            meta={<span className="font-mono">{person.id}</span>}
             chips={roles.length ? roles.map((role) => <Chip key={role}>{role}</Chip>) : undefined}
           />
 
-          {archived || person.discrepancies.length ? (
+          {refusals.length || waiting || (pending && !linked) || archived ? (
             <div className="flex flex-col gap-2">
-              {archived ? (
-                <InlineAlert tone="neutral">
-                  No active roles left. The record stays for history; it no longer appears in team or admin lists.
+              {refusals.map((assignment) => (
+                <InlineAlert key={assignment.id} tone="danger">
+                  PoliNetwork Auth refused to {assignment.change === "start" ? "give" : "take back"} the{" "}
+                  {assignmentLabel(assignment)} role: {assignment.refusal ?? "no reason given"}
+                  {/[.!?]$/.test(assignment.refusal ?? "") ? "" : "."}
+                  {assignment.change === "start" ? " Someone with clearance can assign it again." : ""}
+                </InlineAlert>
+              ))}
+              {waiting ? (
+                <InlineAlert tone="info">
+                  A role change is waiting for PoliNetwork Auth. Other role changes for {person.firstName} wait until it
+                  answers.
                 </InlineAlert>
               ) : null}
-              {person.discrepancies.map((discrepancy, index) => (
-                <InlineAlert
-                  key={`${discrepancy.kind}-${index}`}
-                  tone="warning"
-                  action={
-                    // The update resends the whole profile: an unknown stored year would be replaced, so edit instead.
-                    discrepancy.kind === "telegram-mismatch" &&
-                    discrepancy.suggestedTelegram &&
-                    canWrite &&
-                    yearOf(profile.year) === profile.year ? (
-                      <LoadingButton
-                        size="sm"
-                        variant="ghost"
-                        pending={applyingTelegram}
-                        onClick={() => void applyCensusTelegram(discrepancy.suggestedTelegram ?? "")}
-                      >
-                        Use @{discrepancy.suggestedTelegram}
-                      </LoadingButton>
-                    ) : undefined
-                  }
-                >
-                  {discrepancy.message}
+              {pending && !linked ? (
+                <InlineAlert tone="neutral">
+                  {person.firstName}'s roles wait until the record is linked to an account: send an invite, or link one
+                  by hand.
                 </InlineAlert>
-              ))}
+              ) : null}
+              {archived && !refusals.length ? (
+                <InlineAlert tone="neutral">No current roles. The record stays for history.</InlineAlert>
+              ) : null}
             </div>
           ) : null}
 
           <div className="grid items-start gap-4 min-[1100px]:grid-cols-[minmax(0,1.55fr)_minmax(0,1fr)]">
             <div className="flex min-w-0 flex-col gap-4">
               <SectionCard
-                title="Profile"
+                title="Roles"
+                count={open.length}
+                padding="flush"
+                action={<ActionMenu label="Add a role" actions={addActions} />}
+              >
+                {open.length === 0 ? <SectionEmpty title="No roles" /> : null}
+                <Rows>
+                  {open.map((assignment) => (
+                    <Row
+                      key={assignment.id}
+                      lead={<RowIcon icon={KIND_ICON[assignment.kind]} />}
+                      title={
+                        isTeamAssignment(assignment) ? (
+                          <>
+                            <Link
+                              to="/dashboard/people/teams/$teamId"
+                              params={{ teamId: assignment.team }}
+                              className="hover:text-(--pn-accent)"
+                            >
+                              {teamName(assignment.team)}
+                            </Link>
+                            <Chip>{assignment.teamRole === "lead" ? "Lead" : "Member"}</Chip>
+                          </>
+                        ) : (
+                          assignmentLabel(assignment)
+                        )
+                      }
+                      meta={
+                        <>
+                          {assignmentMeta(assignment)}
+                          {assignment.kind === "admin" ? (
+                            <>
+                              {" · Capo Admin: "}
+                              {assignment.capoOfReference ? (
+                                <Link
+                                  to="/dashboard/people/$personId"
+                                  params={{ personId: assignment.capoOfReference.id }}
+                                  className="text-(--pn-accent) hover:underline"
+                                >
+                                  {assignment.capoOfReference.name}
+                                </Link>
+                              ) : (
+                                "none"
+                              )}
+                            </>
+                          ) : null}
+                        </>
+                      }
+                      detail={
+                        isTeamAssignment(assignment) || assignment.refusal ? (
+                          <span className="flex flex-col gap-1">
+                            {isTeamAssignment(assignment) ? <TeamFieldValues assignment={assignment} /> : null}
+                            {assignment.status === "refused" ? <RefusalText refusal={assignment.refusal} /> : null}
+                          </span>
+                        ) : undefined
+                      }
+                      end={
+                        <>
+                          <AssignmentBadge assignment={assignment} showApplied />
+                          <ActionMenu
+                            label={`${assignmentLabel(assignment)} actions`}
+                            actions={roleActions(assignment)}
+                          />
+                        </>
+                      }
+                    />
+                  ))}
+                </Rows>
+              </SectionCard>
+
+              <SectionCard
+                title="Contacts"
                 action={
                   canWrite ? (
                     <Button size="sm" variant="ghost" className={buttonMotion} onClick={edit.show}>
@@ -219,169 +390,22 @@ export function PersonPage({ person }: { person: PersonRecord }) {
                   ) : undefined
                 }
               >
-                <KeyValueList items={profileItems} />
+                <KeyValueList items={contactItems} />
               </SectionCard>
 
-              {admin ? (
-                <SectionCard
-                  title="Admin"
-                  padding="flush"
-                  action={
-                    admin.status === "active" ? (
-                      <ActionMenu
-                        label="Admin actions"
-                        actions={[
-                          canWrite &&
-                            !admin.capoScope && {
-                              label: "Capo Admin of reference",
-                              icon: UserRoundCog,
-                              onClick: () => adminDialog.show("capoRef"),
-                            },
-                          canAppoint && {
-                            label: admin.capoScope ? "Change Capo Admin scope" : "Appoint as Capo Admin",
-                            icon: Crown,
-                            onClick: () => adminDialog.show("capoScope"),
-                          },
-                          canAppoint &&
-                            admin.capoScope !== null && {
-                              label: "End Capo Admin role",
-                              icon: Crown,
-                              destructive: true,
-                              onClick: () => adminDialog.show("endCapo"),
-                            },
-                          // Ending a Capo Admin's admin role also ends the scope, which takes people:appoint.
-                          canWrite &&
-                            (canAppoint || !admin.capoScope) && {
-                              label: "End admin role",
-                              icon: UserMinus,
-                              destructive: true,
-                              onClick: () => adminDialog.show("end"),
-                            },
-                        ]}
-                      />
-                    ) : undefined
-                  }
-                >
-                  <div className="p-4">
-                    <KeyValueList
-                      items={[
-                        {
-                          key: "Status",
-                          value: (
-                            <StateBadge
-                              state={
-                                admin.status === "active"
-                                  ? { label: "Active", tone: "success" }
-                                  : { label: "Former", tone: "neutral" }
-                              }
-                            />
-                          ),
-                        },
-                        { key: "Active since", value: formatDay(admin.since) },
-                        ...(admin.endedOn
-                          ? [
-                              {
-                                key: "Ended",
-                                value: `${formatDay(admin.endedOn)}${admin.endReason ? ` · ${admin.endReason}` : ""}`,
-                              },
-                            ]
-                          : []),
-                        { key: "Available as Capo Admin", value: admin.availableAsCapo ? "Yes" : "No" },
-                        {
-                          key: "Capo Admin of reference",
-                          value: admin.capoOfReference ? (
-                            <Link
-                              to="/dashboard/people/$personId"
-                              params={{ personId: admin.capoOfReference.id }}
-                              className="text-(--pn-accent) hover:underline"
-                            >
-                              {admin.capoOfReference.name}
-                            </Link>
-                          ) : null,
-                        },
-                        ...(admin.capoScope ? [{ key: "Capo Admin of", value: <Chip>{admin.capoScope}</Chip> }] : []),
-                      ]}
-                    />
-                  </div>
-                </SectionCard>
-              ) : null}
-
-              {person.teams.length || canWrite ? (
-                <SectionCard
-                  title="Teams"
-                  padding="flush"
-                  action={
-                    canWrite ? (
-                      <Button variant="ghost" size="sm" className={buttonMotion} onClick={addTeam.show}>
-                        <UserPlus data-icon="inline-start" />
-                        Add to team
-                      </Button>
-                    ) : undefined
-                  }
-                >
-                  {person.teams.length === 0 ? <SectionEmpty title="Not in any team" /> : null}
+              {history.length ? (
+                <SectionCard title="Past roles" count={history.length} padding="flush">
                   <Rows>
-                    {person.teams.map((membership) => (
+                    {history.map((assignment) => (
                       <Row
-                        key={`${membership.team}-${membership.since}`}
-                        lead={<RowIcon icon={Users} />}
-                        title={
-                          <>
-                            <Link
-                              to="/dashboard/people/teams/$teamId"
-                              params={{ teamId: membership.team }}
-                              className="hover:text-(--pn-accent)"
-                            >
-                              {teamName(membership.team)}
-                            </Link>
-                            <Chip>{membership.role === "lead" ? "Lead" : "Member"}</Chip>
-                          </>
-                        }
-                        meta={
-                          membership.endedOn
-                            ? `Ended ${formatDay(membership.endedOn)}${membership.endReason ? ` · ${membership.endReason}` : ""}`
-                            : `Since ${formatDay(membership.since)}`
-                        }
+                        key={assignment.id}
+                        lead={<RowIcon icon={History} />}
+                        title={<span className="text-(--pn-fg-muted)">{assignmentLabel(assignment)}</span>}
+                        meta={assignmentMeta(assignment)}
                         detail={
-                          <span className="flex flex-wrap gap-x-3 gap-y-1">
-                            {teamFields(membership.team).map((field) => {
-                              const value = membership.fields[field.key]
-                              const text = Array.isArray(value) ? value.join(", ") : value
-                              return (
-                                <span key={field.key}>
-                                  <span className="text-(--pn-fg-muted)">{field.label} </span>
-                                  {text ? (
-                                    <span className={field.mono ? "font-mono" : undefined}>{text}</span>
-                                  ) : (
-                                    <Unset />
-                                  )}
-                                </span>
-                              )
-                            })}
-                          </span>
-                        }
-                        end={
-                          canWrite && !membership.endedOn ? (
-                            <ActionMenu
-                              label={`${teamName(membership.team)} actions`}
-                              actions={[
-                                {
-                                  label: "Edit team fields",
-                                  ariaLabel: `Edit the ${teamName(membership.team)} team fields`,
-                                  icon: Pencil,
-                                  onClick: () => openTeam("fields", membership),
-                                },
-                                (membership.role !== "lead" || canAppoint) && {
-                                  label: "End membership",
-                                  ariaLabel: `End the ${teamName(membership.team)} membership`,
-                                  icon: UserMinus,
-                                  destructive: true,
-                                  onClick: () => openTeam("end", membership),
-                                },
-                              ]}
-                            />
-                          ) : undefined
+                          assignment.status === "refused" ? <RefusalText refusal={assignment.refusal} /> : undefined
                         }
+                        end={assignment.status === "refused" ? <AssignmentBadge assignment={assignment} /> : undefined}
                       />
                     ))}
                   </Rows>
@@ -393,19 +417,19 @@ export function PersonPage({ person }: { person: PersonRecord }) {
               <SectionCard
                 title="Account"
                 footer={
-                  canWrite ? (
+                  canWrite || canLink ? (
                     <div className="flex flex-wrap gap-2">
-                      {account.status === "none" && profile.personalEmail ? (
+                      {canWrite && account.status === "none" && person.contactEmail ? (
                         <Button
                           size="sm"
                           className={buttonMotion}
-                          onClick={() => openAccount("invite", profile.personalEmail ?? "")}
+                          onClick={() => openAccount("invite", person.contactEmail ?? "")}
                         >
                           <Mail data-icon="inline-start" />
                           Send invite
                         </Button>
                       ) : null}
-                      {account.status === "invite" ? (
+                      {canWrite && account.status === "invite" ? (
                         <Button
                           size="sm"
                           variant="outline"
@@ -416,13 +440,13 @@ export function PersonPage({ person }: { person: PersonRecord }) {
                           Resend invite
                         </Button>
                       ) : null}
-                      {account.status !== "linked" ? (
+                      {canLink && account.status !== "linked" ? (
                         <Button size="sm" variant="outline" className={buttonMotion} onClick={link.show}>
                           <Link2 data-icon="inline-start" />
                           Link account
                         </Button>
                       ) : null}
-                      {account.status === "invite" ? (
+                      {canWrite && account.status === "invite" ? (
                         <Button
                           size="sm"
                           variant="ghost"
@@ -432,12 +456,13 @@ export function PersonPage({ person }: { person: PersonRecord }) {
                           Revoke invite
                         </Button>
                       ) : null}
-                      {account.status === "linked" ? (
+                      {canLink && account.status === "linked" ? (
                         <Button
                           size="sm"
                           variant="outline"
                           className={`${buttonMotion} text-(--pn-danger-fg)`}
-                          onClick={() => openAccount("unlink", account.email)}
+                          disabled={waiting}
+                          onClick={unlink.show}
                         >
                           <Unlink data-icon="inline-start" />
                           Unlink
@@ -449,8 +474,9 @@ export function PersonPage({ person }: { person: PersonRecord }) {
               >
                 {account.status === "none" ? (
                   <p className="text-[13px] text-(--pn-fg-muted)">
-                    {profile.firstName} hasn't signed in. The record works without an account; linking lets them use My
-                    area.
+                    No account linked. {person.firstName}'s roles wait here until {person.firstName} accepts an invite,
+                    signing in with any account, or someone links one by hand.
+                    {person.contactEmail ? "" : " Add a contact email to send an invite."}
                   </p>
                 ) : null}
                 {account.status === "invite" ? (
@@ -460,7 +486,7 @@ export function PersonPage({ person }: { person: PersonRecord }) {
                         key: "Invite sent to",
                         value: <span className="[overflow-wrap:anywhere]">{account.email}</span>,
                       },
-                      { key: "Sent on", value: `${formatDay(account.sentOn)} by ${account.sentBy}` },
+                      { key: "Sent on", value: `${formatDay(account.sentOn)} by ${actorName(account.sentBy, people)}` },
                       {
                         key: "Expires on",
                         value: isExpired(account.expiresOn) ? (
@@ -476,43 +502,18 @@ export function PersonPage({ person }: { person: PersonRecord }) {
                   <KeyValueList
                     items={[
                       {
-                        key: "Sign-in",
-                        value: <span className="[overflow-wrap:anywhere]">{account.email}</span>,
+                        key: "Account",
+                        value: <span className="[overflow-wrap:anywhere]">{account.sub}</span>,
                         mono: true,
                       },
-                      { key: "Signed in with", value: account.via },
-                      { key: "Linked on", value: formatDay(account.linkedOn) },
-                      { key: "How", value: account.how },
+                      { key: "How", value: LINK_METHOD[account.method] },
+                      { key: "Linked on", value: account.linkedOn ? formatDay(account.linkedOn) : null },
+                      { key: "Linked by", value: account.linkedBy ? actorName(account.linkedBy, people) : null },
                     ]}
                   />
                 ) : null}
               </SectionCard>
 
-              <SectionCard title="Consents" padding="flush">
-                {person.consents.privacy || person.consents.photo ? (
-                  <Rows>
-                    {person.consents.privacy ? (
-                      <Row
-                        lead={<RowIcon icon={FileText} />}
-                        title="Volunteer privacy policy"
-                        meta={`Version ${person.consents.privacy.version} · accepted ${formatDay(person.consents.privacy.acceptedOn)}`}
-                        end={<StatusBadge tone="success">Accepted</StatusBadge>}
-                      />
-                    ) : null}
-                    {person.consents.photo ? (
-                      <Row
-                        lead={<RowIcon icon={Camera} />}
-                        title="Photo and video"
-                        meta={`${PHOTO_CONSENT[person.consents.photo.status].label} ${formatDay(person.consents.photo.on)}`}
-                        end={<StateBadge state={PHOTO_CONSENT[person.consents.photo.status]} />}
-                      />
-                    ) : null}
-                  </Rows>
-                ) : (
-                  <SectionEmpty title="No consents yet" />
-                )}
-              </SectionCard>
-
               {canRead ? (
                 <SectionCard
                   title="HR notes"
@@ -540,18 +541,21 @@ export function PersonPage({ person }: { person: PersonRecord }) {
               <SectionEmpty title="No activity yet" />
             ) : (
               <Rows>
-                {person.activity.map((entry) => (
-                  <Row
-                    key={`${entry.at}-${entry.text}`}
-                    lead={<PersonAvatar name={entry.actor} size={24} />}
-                    title={
-                      <span className="font-normal">
-                        <span className="font-medium">{entry.actor}</span> {entry.text}
-                      </span>
-                    }
-                    meta={formatDateTime(new Date(entry.at))}
-                  />
-                ))}
+                {person.activity.map((entry) => {
+                  const actor = actorName(entry.actor, people)
+                  return (
+                    <Row
+                      key={`${entry.at}-${entry.text}`}
+                      lead={<PersonAvatar name={actor} size={24} />}
+                      title={
+                        <span className="font-normal [overflow-wrap:anywhere]">
+                          <span className="font-medium">{actor}</span> {entry.text}
+                        </span>
+                      }
+                      meta={formatDateTime(new Date(entry.at))}
+                    />
+                  )
+                })}
               </Rows>
             )}
           </SectionCard>
@@ -573,73 +577,86 @@ export function PersonPage({ person }: { person: PersonRecord }) {
             open={accountDialog.open}
             onOpenChange={accountDialog.onOpenChange}
           />
-          <LinkAccountDialog
-            key={`link-${link.key}`}
-            open={link.open}
-            onOpenChange={link.onOpenChange}
-            person={{ id: person.id, name, firstName: profile.firstName }}
-          />
           <AddToTeamDialog
             key={`add-team-${addTeam.key}`}
             open={addTeam.open}
             onOpenChange={addTeam.onOpenChange}
-            teams={TEAM_IDS.filter((team) => !activeTeams(person).some((membership) => membership.team === team))}
-            person={{ id: person.id, name }}
+            teams={TEAM_IDS.filter((team) => !teams.some((assignment) => assignment.team === team))}
+            availability={teamSummaries}
+            person={option}
             canAppoint={canAppoint}
           />
         </>
       ) : null}
-      {teamDialog.target ? (
-        teamDialog.target.kind === "fields" ? (
-          <EditTeamFieldsDialog
-            key={`fields-${teamDialog.key}`}
-            open={teamDialog.open}
-            onOpenChange={teamDialog.onOpenChange}
-            target={teamDialog.target.target}
-          />
-        ) : (
-          <EndTeamMembershipDialog
-            key={`end-team-${teamDialog.key}`}
-            open={teamDialog.open}
-            onOpenChange={teamDialog.onOpenChange}
-            target={teamDialog.target.target}
-          />
-        )
-      ) : null}
-      {admin && adminDialog.target ? (
-        adminDialog.target === "end" ? (
-          <EndAdminDialog
-            key={`end-${adminDialog.key}`}
-            open={adminDialog.open}
-            onOpenChange={adminDialog.onOpenChange}
-            target={adminTarget}
-          />
-        ) : adminDialog.target === "capoRef" ? (
-          <CapoOfReferenceDialog
-            key={`ref-${adminDialog.key}`}
-            open={adminDialog.open}
-            onOpenChange={adminDialog.onOpenChange}
-            target={adminTarget}
-            current={admin.capoOfReference?.id ?? null}
-          />
-        ) : adminDialog.target === "capoScope" ? (
-          <CapoScopeDialog
-            key={`scope-${adminDialog.key}`}
-            open={adminDialog.open}
-            onOpenChange={adminDialog.onOpenChange}
-            target={adminTarget}
-            scope={admin.capoScope}
+      {canLink ? (
+        <>
+          <LinkAccountDialog
+            key={`link-${link.key}`}
+            open={link.open}
+            onOpenChange={link.onOpenChange}
+            person={{ id: person.id, name, firstName: person.firstName }}
           />
-        ) : (
-          <EndCapoDialog
-            key={`end-capo-${adminDialog.key}`}
-            open={adminDialog.open}
-            onOpenChange={adminDialog.onOpenChange}
-            target={adminTarget}
-            scope={admin.capoScope ?? ""}
+          <UnlinkAccountDialog
+            key={`unlink-${unlink.key}`}
+            open={unlink.open}
+            onOpenChange={unlink.onOpenChange}
+            person={{ id: person.id, name, roles: roles.length }}
           />
-        )
+        </>
       ) : null}
+      {roleDialog.target ? <RoleDialogs dialog={roleDialog} person={person} option={option} target={target} /> : null}
     </>
   )
 }
+
+/** The dialog of the role action that was chosen. */
+function RoleDialogs({
+  dialog,
+  person,
+  option,
+  target,
+}: {
+  dialog: ReturnType<typeof useDialog<RoleDialog>>
+  person: PersonRecord
+  option: { id: string; name: string; linked: boolean }
+  target: { personId: string; name: string }
+}) {
+  const state = { open: dialog.open, onOpenChange: dialog.onOpenChange }
+  const choice = dialog.target
+  if (!choice) return null
+  const admin = currentAdmin(person)
+  const capo = currentCapo(person)
+  switch (choice.kind) {
+    case "assignAdmin":
+      return <AssignAdminDialog key={`assign-${dialog.key}`} {...state} person={option} />
+    case "endAdmin":
+      return <EndAdminDialog key={`end-${dialog.key}`} {...state} target={target} linked={option.linked} />
+    case "capoRef":
+      return (
+        <CapoOfReferenceDialog
+          key={`ref-${dialog.key}`}
+          {...state}
+          target={target}
+          current={admin?.capoOfReference?.id ?? null}
+        />
+      )
+    case "appointCapo":
+      return <AppointCapoDialog key={`appoint-${dialog.key}`} {...state} person={option} />
+    case "capoScope":
+      return <CapoScopeDialog key={`scope-${dialog.key}`} {...state} target={target} scope={capo?.capoScope ?? ""} />
+    case "endCapo":
+      return (
+        <EndCapoDialog
+          key={`end-capo-${dialog.key}`}
+          {...state}
+          target={target}
+          linked={option.linked}
+          scope={capo?.capoScope ?? ""}
+        />
+      )
+    case "teamFields":
+      return <EditTeamFieldsDialog key={`fields-${dialog.key}`} {...state} target={choice.target} />
+    case "endTeam":
+      return <EndTeamMembershipDialog key={`end-team-${dialog.key}`} {...state} target={choice.target} />
+  }
+}
diff --git a/src/features/people/team-dialogs.tsx b/src/features/people/team-dialogs.tsx
index a5cb0dd..f5d39af 100644
--- a/src/features/people/team-dialogs.tsx
+++ b/src/features/people/team-dialogs.tsx
@@ -16,13 +16,16 @@ import { Input } from "@/components/ui/input"
 import { Textarea } from "@/components/ui/textarea"
 import { cn } from "@/lib/utils"
 
+import { changeOutcome } from "./admin-dialogs"
 import { teamName, todayIso } from "./people-format"
-import { errorMessage, useLoaded, useRefreshAfter } from "./people-hooks"
+import { errorMessage, useLoaded, useRefreshAfter, useReloadAfterFailure } from "./people-hooks"
 import { addTeamMember, endTeamMembership, getTeamCandidates, updateTeamFields } from "./people-teams.functions"
 import { ChoiceChips, type PersonOption, PersonPicker } from "./people-ui"
-import { TEAM_IDS, type TeamFields, teamFields, type TeamId } from "./people.contract"
+import { TEAM_IDS, type TeamFields, teamFields, type TeamId, type TeamRole, type TeamSummary } from "./people.contract"
 
-type Role = "member" | "lead"
+type Role = TeamRole
+/** Which roles PoliNetwork Auth binds for each team, and whether it already has a Lead. */
+export type TeamAvailability = Pick<TeamSummary, "id" | "assignable" | "lead">
 
 function emptyFields(team: TeamId): TeamFields {
   return Object.fromEntries(teamFields(team).map((field) => [field.key, field.kind === "multi" ? [] : ""]))
@@ -84,13 +87,14 @@ function TeamFieldInputs({
 
 /**
  * Adds an existing person to a team. `team` fixes the team (a team page); `person` fixes the person (their record).
- * The Lead role is offered only with `people:appoint`.
+ * Only roles Auth binds are offered, and the Lead role only with `people:appoint` to a team without one.
  */
 export function AddToTeamDialog({
   open,
   onOpenChange,
   team: fixedTeam,
   teams = TEAM_IDS,
+  availability = [],
   person: fixedPerson,
   canAppoint,
 }: {
@@ -99,12 +103,15 @@ export function AddToTeamDialog({
   team?: TeamId
   /** Teams to choose from when `team` isn't fixed. */
   teams?: readonly TeamId[]
-  person?: PersonOption
+  /** What Auth binds per team; a team missing here is offered as assignable. */
+  availability?: readonly TeamAvailability[]
+  person?: PersonOption & { linked: boolean }
   canAppoint: boolean
 }) {
   const add = useServerFn(addTeamMember)
   const loadCandidates = useServerFn(getTeamCandidates)
   const refresh = useRefreshAfter()
+  const reload = useReloadAfterFailure()
   const [team, setTeam] = useState<TeamId | null>(fixedTeam ?? null)
   const [person, setPerson] = useState<PersonOption | null>(fixedPerson ?? null)
   const [role, setRole] = useState<Role>("member")
@@ -120,6 +127,17 @@ export function AddToTeamDialog({
   )
   const candidates = candidateRows?.map((row) => ({ id: row.id, name: row.name })) ?? null
 
+  const available = (id: TeamId | null) => availability.find((entry) => entry.id === id)
+  const memberBound = (id: TeamId) => available(id)?.assignable.member ?? true
+  const leadOpen = (id: TeamId | null) => {
+    const entry = available(id)
+    return canAppoint && (entry ? entry.assignable.lead && !entry.lead : true)
+  }
+  const choosable = teams.filter((id) => memberBound(id) || leadOpen(id))
+  // A team that only binds a Lead role takes a Lead; one that can't take a Lead (another team chosen after "Team Lead")
+  // takes a member.
+  const roleChoice: Role = !team ? role : !memberBound(team) ? "lead" : leadOpen(team) ? role : "member"
+
   const teamError = submitted && !team ? "Choose a team." : undefined
   const personError = submitted && !person ? "Choose a person." : undefined
   const sinceError = submitted && !since ? "Choose the start date." : undefined
@@ -129,12 +147,17 @@ export function AddToTeamDialog({
     setSubmitted(true)
     if (!team || !person || !since) return
     try {
-      await add({ data: { teamId: team, personId: person.id, role, since, fields: cleanFields(fields) } })
+      await add({ data: { teamId: team, personId: person.id, role: roleChoice, since, fields: cleanFields(fields) } })
     } catch (caught) {
       console.error(caught)
+      reload()
       throw new Error(errorMessage(caught, "Couldn't add the person to the team."), { cause: caught })
     }
-    await refresh(`${person.name} added to ${teamName(team)}.`)
+    await refresh(
+      fixedPerson
+        ? changeOutcome(fixedPerson.linked, `${person.name} added to ${teamName(team)}.`)
+        : `${person.name} added to ${teamName(team)}.`
+    )
     onOpenChange(false)
   }
 
@@ -162,7 +185,7 @@ export function AddToTeamDialog({
             <SelectField<TeamId>
               id="team-add-team"
               value={team}
-              options={teams.map((value) => ({ value, label: teamName(value) }))}
+              options={choosable.map((value) => ({ value, label: teamName(value) }))}
               onChange={(next) => {
                 setTeam(next)
                 setFields(emptyFields(next))
@@ -195,11 +218,11 @@ export function AddToTeamDialog({
           </FormField>
         )}
         <div className="grid grid-cols-1 gap-4 shell:grid-cols-2">
-          {canAppoint ? (
+          {leadOpen(team) && (!team || memberBound(team)) ? (
             <div className="shell:col-span-2">
               <RadioCardGroup
                 label="Role"
-                value={role}
+                value={roleChoice}
                 onValueChange={setRole}
                 className="grid grid-cols-1 gap-2 shell:grid-cols-2"
               >
@@ -224,7 +247,13 @@ export function AddToTeamDialog({
   )
 }
 
-export type TeamMemberTarget = { personId: string; name: string; team: TeamId; fields: TeamFields }
+export type TeamMemberTarget = {
+  personId: string
+  name: string
+  team: TeamId
+  fields: TeamFields
+  linked: boolean
+}
 
 export function EditTeamFieldsDialog({
   open,
@@ -278,7 +307,7 @@ const END_REASONS = [
 ] as const
 type EndReason = (typeof END_REASONS)[number]
 
-/** Ends a team membership with its last day and reason; the history stays. */
+/** Ends a team membership with a reason; the history stays. A linked record's role is taken back in Auth. */
 export function EndTeamMembershipDialog({
   open,
   onOpenChange,
@@ -290,32 +319,27 @@ export function EndTeamMembershipDialog({
 }) {
   const end = useServerFn(endTeamMembership)
   const refresh = useRefreshAfter()
+  const reload = useReloadAfterFailure()
   const [reason, setReason] = useState<EndReason | null>(null)
-  const [lastDay, setLastDay] = useState(todayIso())
   const [note, setNote] = useState("")
   const [submitted, setSubmitted] = useState(false)
   const reasonError = submitted && !reason ? "Choose a reason." : undefined
   const noteError = submitted && reason === "Other" && !note.trim() ? "Describe the reason." : undefined
-  const lastDayError = submitted && !lastDay ? "Choose the last day." : undefined
 
   async function submit() {
     setSubmitted(true)
-    if (!reason || !lastDay || (reason === "Other" && !note.trim())) return
+    if (!reason || (reason === "Other" && !note.trim())) return
+    const text = reason === "Other" ? note.trim() : note.trim() ? `${reason}: ${note.trim()}` : reason
     try {
-      await end({
-        data: {
-          teamId: target.team,
-          personId: target.personId,
-          lastDay,
-          reason: reason === "Other" ? note.trim() : reason,
-          note: reason === "Other" ? "" : note.trim(),
-        },
-      })
+      await end({ data: { teamId: target.team, personId: target.personId, reason: text } })
     } catch (caught) {
       console.error(caught)
+      reload()
       throw new Error(errorMessage(caught, "Couldn't end the membership."), { cause: caught })
     }
-    await refresh("Membership ended.")
+    await refresh(
+      target.linked ? "Membership ending. PoliNetwork Auth takes the role back shortly." : "Membership ended."
+    )
     onOpenChange(false)
   }
 
@@ -324,7 +348,7 @@ export function EndTeamMembershipDialog({
       open={open}
       onOpenChange={onOpenChange}
       title="End membership?"
-      description={`${target.name} leaves ${teamName(target.team)} on the last day below. Their history stays.`}
+      description={`${target.name} leaves ${teamName(target.team)} today. Their history stays.`}
       noun="change"
       dirty={reason !== null || note.trim() !== ""}
       submitLabel="End membership"
@@ -332,27 +356,16 @@ export function EndTeamMembershipDialog({
       onSubmit={submit}
     >
       <div className="flex flex-col gap-4">
-        <div className="grid grid-cols-1 gap-4 shell:grid-cols-2">
-          <FormField label="Reason" htmlFor="end-team-reason" error={reasonError}>
-            <SelectField<EndReason>
-              id="end-team-reason"
-              value={reason}
-              options={END_REASONS.map((value) => ({ value, label: value }))}
-              onChange={setReason}
-              placeholder="Choose a reason"
-              invalid={!!reasonError}
-            />
-          </FormField>
-          <FormField label="Last day" htmlFor="end-team-last-day" error={lastDayError}>
-            <DateField
-              id="end-team-last-day"
-              value={lastDay}
-              onChange={setLastDay}
-              invalid={!!lastDayError}
-              describedBy={lastDayError ? fieldHintId("end-team-last-day") : undefined}
-            />
-          </FormField>
-        </div>
+        <FormField label="Reason" htmlFor="end-team-reason" error={reasonError}>
+          <SelectField<EndReason>
+            id="end-team-reason"
+            value={reason}
+            options={END_REASONS.map((value) => ({ value, label: value }))}
+            onChange={setReason}
+            placeholder="Choose a reason"
+            invalid={!!reasonError}
+          />
+        </FormField>
         <FormField
           label="Note"
           htmlFor="end-team-note"
@@ -364,7 +377,7 @@ export function EndTeamMembershipDialog({
             id="end-team-note"
             value={note}
             onChange={(event) => setNote(event.target.value)}
-            maxLength={500}
+            maxLength={400}
             aria-invalid={noteError ? true : undefined}
             aria-describedby={fieldHintId("end-team-note")}
             className={cn(fieldControl, "min-h-20")}
diff --git a/src/features/people/teams-page.tsx b/src/features/people/teams-page.tsx
index eb238ec..13d9d79 100644
--- a/src/features/people/teams-page.tsx
+++ b/src/features/people/teams-page.tsx
@@ -20,31 +20,48 @@ import {
   type TableSort,
   Unset,
 } from "@/components/primitives"
+import { Hint } from "@/components/primitives/hint"
 import { Count, PageBar, PageContent, Toolbar, useCan, useHasAdminAccess, usePeopleRoles } from "@/components/shell"
 import { Button } from "@/components/ui/button"
 import { pluralize } from "@/lib/format"
 
-import { formatDay, personName, PHOTO_CONSENT, teamName } from "./people-format"
+import {
+  assignmentState,
+  formatDay,
+  isTeamAssignment,
+  personName,
+  type TeamAssignment,
+  teamName,
+  waitingForAuth,
+} from "./people-format"
 import { useDialog, useDialogState } from "./people-hooks"
-import { ActionMenu, PersonCell, StateBadge } from "./people-ui"
-import { type PersonRow, type TeamId, type TeamMembership, type TeamSummary, teamFields } from "./people.contract"
+import { ActionMenu, AssignmentBadge, PersonCell } from "./people-ui"
+import { type PersonRow, type TeamId, type TeamRole, type TeamSummary, teamFields } from "./people.contract"
 import { AddToTeamDialog, EditTeamFieldsDialog, EndTeamMembershipDialog, type TeamMemberTarget } from "./team-dialogs"
 
 /** One person's membership of one team: a table row on the Teams pages. */
-type TeamRow = { person: PersonRow; membership: TeamMembership }
-type Role = TeamMembership["role"]
+type TeamRow = { person: PersonRow; membership: TeamAssignment }
+type Role = TeamRole
 type TeamDialog = { kind: "fields" | "end"; target: TeamMemberTarget }
 
+/**
+ * A team's current memberships (`ended` false), or its past ones. An ending Auth hasn't confirmed yet stays with the
+ * current ones, with its badge.
+ */
 function rowsOf(team: TeamSummary, ended: boolean): TeamRow[] {
   return team.members.flatMap((person) =>
-    person.teams
-      .filter((membership) => membership.team === team.id && (membership.endedOn !== null) === ended)
+    person.assignments
+      .filter(isTeamAssignment)
+      .filter(
+        (membership) =>
+          membership.team === team.id && (membership.endedOn !== null && membership.status !== "sent") === ended
+      )
       .map((membership) => ({ person, membership }))
   )
 }
 
 function rowId(row: TeamRow) {
-  return `${row.person.id}-${row.membership.team}-${row.membership.since}`
+  return row.membership.id
 }
 
 function targetOf(row: TeamRow): TeamMemberTarget {
@@ -53,21 +70,35 @@ function targetOf(row: TeamRow): TeamMemberTarget {
     name: personName(row.person),
     team: row.membership.team,
     fields: row.membership.fields,
+    linked: row.person.account.status === "linked",
   }
 }
 
 function matchesQuery(row: TeamRow, query: string) {
   if (!query) return true
   const fieldValues = Object.values(row.membership.fields).flat()
-  return [personName(row.person), row.person.profile.telegramUsername ?? "", ...fieldValues].some((value) =>
-    value.toLocaleLowerCase().includes(query)
+  return [personName(row.person), row.person.telegramUsername ?? "", ...fieldValues].some((value) =>
+    value.toLocaleLowerCase().includes(query.replace(/^@/, ""))
   )
 }
 
-function PhotoBadge({ person }: { person: PersonRow }) {
-  const photo = person.consents.photo
-  if (!photo) return <Unset />
-  return <StateBadge state={PHOTO_CONSENT[photo.status]} />
+/** Where the membership stands with Auth; a refusal's reason is the badge's tooltip, and on the person's record. */
+function MembershipStatus({ membership }: { membership: TeamAssignment }) {
+  return (
+    <Hint label={membership.status === "refused" ? membership.refusal : null}>
+      <span className="inline-flex min-w-0">
+        <AssignmentBadge assignment={membership} />
+      </span>
+    </Hint>
+  )
+}
+
+/** Why nobody, or no Lead, can be added: Auth binds no role for it. */
+function bindingNote(team: TeamSummary) {
+  if (!team.assignable.member && !team.assignable.lead) return "No role bound in PoliNetwork Auth: nobody can be added"
+  if (!team.assignable.lead) return "No Lead role bound in PoliNetwork Auth"
+  if (!team.assignable.member) return "No member role bound in PoliNetwork Auth"
+  return null
 }
 
 function RoleChip({ role }: { role: Role }) {
@@ -86,7 +117,10 @@ function MemberActions({
   onOpen: (dialog: TeamDialog) => void
 }) {
   const name = personName(row.person)
-  const canEnd = row.membership.role !== "lead" || canAppoint
+  // Nothing to end while Auth hasn't answered: the backend refuses another change until it does.
+  const ending = row.membership.endedOn !== null
+  const canEnd = !ending && !waitingForAuth(row.person) && (row.membership.teamRole !== "lead" || canAppoint)
+  if (ending) return <span aria-hidden className="size-9" />
   return (
     <RowActions>
       <IconButton
@@ -137,12 +171,14 @@ function useTeamDialog() {
 
 const DEFAULT_SORT: TableSort = { column: "name", direction: "asc" }
 
-function sortRows(rows: TeamRow[], sort: TableSort) {
+/** By name, or by the date column: the start, or the end for former members (`ended`). */
+function sortRows(rows: TeamRow[], sort: TableSort, ended = false) {
   const sign = sort.direction === "asc" ? 1 : -1
+  const date = (row: TeamRow) => (ended ? row.membership.endedOn : null) ?? row.membership.since
   return rows.toSorted(
     (a, b) =>
       (sort.column === "since"
-        ? a.membership.since.localeCompare(b.membership.since)
+        ? date(a).localeCompare(date(b))
         : personName(a.person).localeCompare(personName(b.person))) * sign
   )
 }
@@ -167,7 +203,7 @@ export function TeamsPage({ teams }: { teams: TeamSummary[] }) {
   const filtered = all.filter(
     (row) =>
       (team === null || row.membership.team === team) &&
-      (role === null || row.membership.role === role) &&
+      (role === null || row.membership.teamRole === role) &&
       matchesQuery(row, deferredQuery)
   )
   const sorted = sortRows(filtered, sort)
@@ -191,10 +227,11 @@ export function TeamsPage({ teams }: { teams: TeamSummary[] }) {
       mobile: "main",
       cell: (row) => (
         <>
-          <PersonCell name={personName(row.person)} secondary={row.person.profile.course} />
+          <PersonCell name={personName(row.person)} />
           <span className="mt-2 hidden flex-wrap items-center gap-1.5 pl-11 max-shell:flex">
             <Chip>{teamName(row.membership.team)}</Chip>
-            {row.membership.role === "lead" ? <Chip>Lead</Chip> : null}
+            {row.membership.teamRole === "lead" ? <Chip>Lead</Chip> : null}
+            <AssignmentBadge assignment={row.membership} />
           </span>
         </>
       ),
@@ -206,7 +243,13 @@ export function TeamsPage({ teams }: { teams: TeamSummary[] }) {
       mobile: "hidden",
       cell: (row) => <Chip>{teamName(row.membership.team)}</Chip>,
     },
-    { id: "role", label: "Role", width: 104, mobile: "hidden", cell: (row) => <RoleChip role={row.membership.role} /> },
+    {
+      id: "role",
+      label: "Role",
+      width: 104,
+      mobile: "hidden",
+      cell: (row) => <RoleChip role={row.membership.teamRole} />,
+    },
     {
       id: "since",
       label: "Since",
@@ -217,12 +260,12 @@ export function TeamsPage({ teams }: { teams: TeamSummary[] }) {
       cell: (row) => <span className="whitespace-nowrap">{formatDay(row.membership.since)}</span>,
     },
     {
-      id: "photo",
-      label: "Photo and video",
-      width: 144,
-      priority: 5,
+      id: "status",
+      label: "With Auth",
+      width: 200,
+      priority: 4,
       mobile: "hidden",
-      cell: (row) => <PhotoBadge person={row.person} />,
+      cell: (row) => <MembershipStatus membership={row.membership} />,
     },
   ]
 
@@ -251,7 +294,12 @@ export function TeamsPage({ teams }: { teams: TeamSummary[] }) {
                   count={active.length}
                   noun="member"
                   description={
-                    <span className="block truncate">{summary.lead ? `Lead: ${summary.lead.name}` : "No lead"}</span>
+                    <span className="flex flex-col">
+                      <span className="block truncate">{summary.lead ? `Lead: ${summary.lead.name}` : "No Lead"}</span>
+                      {bindingNote(summary) ? (
+                        <span className="block truncate text-xs text-(--pn-fg-muted)">{bindingNote(summary)}</span>
+                      ) : null}
+                    </span>
                   }
                   render={<Link to="/dashboard/people/teams/$teamId" params={{ teamId: summary.id }} />}
                 />
@@ -358,6 +406,7 @@ export function TeamsPage({ teams }: { teams: TeamSummary[] }) {
           open={add.open}
           onOpenChange={add.onOpenChange}
           teams={teams.map((summary) => summary.id)}
+          availability={teams}
           canAppoint={canAppoint}
         />
       ) : null}
@@ -402,7 +451,7 @@ export function TeamPage({ team, asSection = false }: { team: TeamSummary; asSec
     }
     return matchesQuery(row, deferredQuery)
   })
-  const rows = sortRows(filtered, sort)
+  const rows = sortRows(filtered, sort, scope === "former")
   const narrowed = deferredQuery !== "" || option !== null
 
   const columns: DataTableColumn<TeamRow>[] = [
@@ -413,11 +462,22 @@ export function TeamPage({ team, asSection = false }: { team: TeamSummary; asSec
       fill: true,
       minWidth: 220,
       mobile: "main",
+      // The Auth column drops first on narrow tables, so a change still waiting or refused also shows here.
       cell: (row) => (
-        <PersonCell name={personName(row.person)} secondary={row.person.profile.course} muted={scope === "former"} />
+        <PersonCell
+          name={personName(row.person)}
+          secondary={row.membership.status === "applied" ? null : assignmentState(row.membership).label}
+          muted={scope === "former"}
+        />
       ),
     },
-    { id: "role", label: "Role", width: 104, mobile: "meta", cell: (row) => <RoleChip role={row.membership.role} /> },
+    {
+      id: "role",
+      label: "Role",
+      width: 104,
+      mobile: "meta",
+      cell: (row) => <RoleChip role={row.membership.teamRole} />,
+    },
     {
       id: "since",
       label: scope === "former" ? "Ended" : "Since",
@@ -464,7 +524,12 @@ export function TeamPage({ team, asSection = false }: { team: TeamSummary; asSec
             label: "Reason",
             width: 184,
             mobile: "text",
-            cell: (row) => row.membership.endReason ?? <Unset />,
+            cell: (row) =>
+              row.membership.status === "refused" ? (
+                <MembershipStatus membership={row.membership} />
+              ) : (
+                (row.membership.endReason ?? <Unset />)
+              ),
           } satisfies DataTableColumn<TeamRow>,
         ]
       : [
@@ -477,10 +542,10 @@ export function TeamPage({ team, asSection = false }: { team: TeamSummary; asSec
                   priority: 3,
                   mobile: "meta",
                   cell: (row) =>
-                    row.person.profile.telegramUsername ? (
+                    row.person.telegramUsername ? (
                       <span className="flex min-w-0 items-center gap-1.5">
                         <PlatformGlyph platform="tg" className="size-3.5 shrink-0" />
-                        <span className="truncate font-mono text-[13px]">@{row.person.profile.telegramUsername}</span>
+                        <span className="truncate font-mono text-[13px]">@{row.person.telegramUsername}</span>
                       </span>
                     ) : (
                       <Unset />
@@ -493,31 +558,28 @@ export function TeamPage({ team, asSection = false }: { team: TeamSummary; asSec
                   priority: 5,
                   mobile: "meta",
                   cell: (row) =>
-                    row.person.profile.phone ? (
-                      <span className="whitespace-nowrap">{row.person.profile.phone}</span>
-                    ) : (
-                      <Unset />
-                    ),
+                    row.person.phone ? <span className="whitespace-nowrap">{row.person.phone}</span> : <Unset />,
                 } satisfies DataTableColumn<TeamRow>,
               ]
             : []),
           {
-            id: "photo",
-            label: "Photo and video",
-            width: 144,
-            priority: 5,
-            mobile: "hidden",
-            cell: (row) => <PhotoBadge person={row.person} />,
+            id: "status",
+            label: "With Auth",
+            width: 200,
+            priority: 4,
+            mobile: "meta",
+            cell: (row) => <MembershipStatus membership={row.membership} />,
           } satisfies DataTableColumn<TeamRow>,
         ]),
   ]
 
-  const addButton = canEdit ? (
-    <Button size="sm" className={buttonMotion} onClick={add.show}>
-      <UserPlus data-icon="inline-start" />
-      Add to team
-    </Button>
-  ) : undefined
+  const addButton =
+    canEdit && (team.assignable.member || (canAppoint && team.assignable.lead && !team.lead)) ? (
+      <Button size="sm" className={buttonMotion} onClick={add.show}>
+        <UserPlus data-icon="inline-start" />
+        Add to team
+      </Button>
+    ) : undefined
 
   const toolbar = (
     <Toolbar
@@ -622,7 +684,13 @@ export function TeamPage({ team, asSection = false }: { team: TeamSummary; asSec
             <div className="flex flex-col gap-6">
               <RecordHeader
                 title={team.name}
-                meta={`${pluralize(active.length, "active member")} · ${team.lead ? `Lead: ${team.lead.name}` : "No lead"}`}
+                meta={[
+                  pluralize(active.length, "active member"),
+                  team.lead ? `Lead: ${team.lead.name}` : "No Lead",
+                  bindingNote(team),
+                ]
+                  .filter(Boolean)
+                  .join(" · ")}
                 actions={addButton}
               />
               {toolbar}
@@ -637,6 +705,7 @@ export function TeamPage({ team, asSection = false }: { team: TeamSummary; asSec
           open={add.open}
           onOpenChange={add.onOpenChange}
           team={team.id}
+          availability={[team]}
           canAppoint={canAppoint}
         />
       ) : null}
diff --git a/src/routes/dashboard/people/$personId.tsx b/src/routes/dashboard/people/$personId.tsx
index bf94952..18b0a75 100644
--- a/src/routes/dashboard/people/$personId.tsx
+++ b/src/routes/dashboard/people/$personId.tsx
@@ -2,11 +2,20 @@ import { createFileRoute } from "@tanstack/react-router"
 
 import { RecordSkeleton } from "@/components/primitives"
 import { PageBar, PageContent } from "@/components/shell"
-import { getPerson } from "@/features/people/people.functions"
+import { getTeams } from "@/features/people/people-teams.functions"
+import { getPeople, getPerson } from "@/features/people/people.functions"
 import { PersonPage } from "@/features/people/person-page"
 
 export const Route = createFileRoute("/dashboard/people/$personId")({
-  loader: ({ params }) => getPerson({ data: { id: params.personId } }),
+  // The other records name who did what (the backend records account IDs); the teams say which roles Auth binds.
+  loader: async ({ params }) => {
+    const [person, people, teams] = await Promise.all([
+      getPerson({ data: { id: params.personId } }),
+      getPeople(),
+      getTeams(),
+    ])
+    return { person, people, teams }
+  },
   pendingComponent: PersonPending,
   component: PersonRoute,
 })
@@ -23,5 +32,6 @@ function PersonPending() {
 }
 
 function PersonRoute() {
-  return <PersonPage person={Route.useLoaderData()} />
+  const { person, people, teams } = Route.useLoaderData()
+  return <PersonPage person={person} people={people} teams={teams} />
 }
diff --git a/src/routes/dashboard/people/admins.tsx b/src/routes/dashboard/people/admins.tsx
index ba73298..fa09c96 100644
--- a/src/routes/dashboard/people/admins.tsx
+++ b/src/routes/dashboard/people/admins.tsx
@@ -3,15 +3,19 @@ import { createFileRoute } from "@tanstack/react-router"
 import { TableSkeleton } from "@/components/primitives"
 import { PageBar, PageContent } from "@/components/shell"
 import { AdminsPage } from "@/features/people/admins-page"
-import { getPeople } from "@/features/people/people.functions"
+import { getAdminsAndCapos, getPeople } from "@/features/people/people.functions"
 
 export const Route = createFileRoute("/dashboard/people/admins")({
-  loader: () => getPeople(),
+  // Every record too: Make admin picks from them.
+  loader: async () => {
+    const [{ admins, capos }, people] = await Promise.all([getAdminsAndCapos(), getPeople()])
+    return { admins, capos, people }
+  },
   pendingComponent: () => (
     <>
       <PageBar />
       <PageContent>
-        <TableSkeleton columns={6} label="Loading admins…" />
+        <TableSkeleton columns={4} label="Loading admins…" />
       </PageContent>
     </>
   ),
@@ -19,5 +23,6 @@ export const Route = createFileRoute("/dashboard/people/admins")({
 })
 
 function AdminsRoute() {
-  return <AdminsPage people={Route.useLoaderData()} />
+  const { admins, capos, people } = Route.useLoaderData()
+  return <AdminsPage admins={admins} capos={capos} people={people} />
 }
diff --git a/src/routes/dashboard/people/index.tsx b/src/routes/dashboard/people/index.tsx
index b5ea2f3..482cbab 100644
--- a/src/routes/dashboard/people/index.tsx
+++ b/src/routes/dashboard/people/index.tsx
@@ -3,10 +3,15 @@ import { createFileRoute } from "@tanstack/react-router"
 import { TableSkeleton } from "@/components/primitives"
 import { PageBar, PageContent } from "@/components/shell"
 import { PeopleOverviewPage } from "@/features/people/overview-page"
+import { getTeams } from "@/features/people/people-teams.functions"
 import { getPeople } from "@/features/people/people.functions"
 
 export const Route = createFileRoute("/dashboard/people/")({
-  loader: () => getPeople(),
+  // Teams say which roles Auth binds, for Add person's initial roles.
+  loader: async () => {
+    const [people, teams] = await Promise.all([getPeople(), getTeams()])
+    return { people, teams }
+  },
   pendingComponent: () => (
     <>
       <PageBar />
@@ -19,5 +24,6 @@ export const Route = createFileRoute("/dashboard/people/")({
 })
 
 function PeopleOverviewRoute() {
-  return <PeopleOverviewPage people={Route.useLoaderData()} />
+  const { people, teams } = Route.useLoaderData()
+  return <PeopleOverviewPage people={people} teams={teams} />
 }
diff --git a/src/server/auth.middleware.ts b/src/server/auth.middleware.ts
index 4dd93e7..459c206 100644
--- a/src/server/auth.middleware.ts
+++ b/src/server/auth.middleware.ts
@@ -75,7 +75,7 @@ export const peopleSelfMiddleware = createMiddleware({ type: "function" })
     return next()
   })
 
-/** People: every record, admins, teams, census and linking, with contacts and HR notes. */
+/** People: every record, admins, Capo Admins, teams and linking, with contacts and HR notes. */
 export const peopleReadMiddleware = createMiddleware({ type: "function" })
   .middleware([adminMiddleware])
   .server(({ next, context }) => {
@@ -83,7 +83,7 @@ export const peopleReadMiddleware = createMiddleware({ type: "function" })
     return next()
   })
 
-/** People: add and edit people, admin roles, team memberships and account linking. */
+/** People: add and edit records, make and end admins, and set their Capo Admin of reference. */
 export const peopleWriteMiddleware = createMiddleware({ type: "function" })
   .middleware([adminMiddleware])
   .server(({ next, context }) => {
@@ -92,8 +92,8 @@ export const peopleWriteMiddleware = createMiddleware({ type: "function" })
   })
 
 /**
- * People › Teams writes: `people:write`, or a Team Lead (`people:self`) on their own team, which only the backend
- * can tell from the record.
+ * People writes a Team Lead may make too: team memberships, and invites to their team's members. `people:write`, or a
+ * Team Lead (`people:self`) on their own team, which only the backend can tell.
  */
 export const peopleTeamWriteMiddleware = createMiddleware({ type: "function" })
   .middleware([dashboardUserMiddleware])
@@ -134,6 +134,14 @@ export const peopleAppointMiddleware = createMiddleware({ type: "function" })
     return next()
   })
 
+/** People: search the IdP's accounts, and link or unlink one by hand. Linking hands the account the record's roles. */
+export const peopleLinkMiddleware = createMiddleware({ type: "function" })
+  .middleware([adminMiddleware])
+  .server(({ next, context }) => {
+    requirePermission(context.permissions, "people:link")
+    return next()
+  })
+
 /** Telegram grants: create and interrupt. */
 export const grantsWriteMiddleware = createMiddleware({ type: "function" })
   .middleware([adminMiddleware])
diff --git a/src/server/permissions.ts b/src/server/permissions.ts
index 2a272ba..855807e 100644
--- a/src/server/permissions.ts
+++ b/src/server/permissions.ts
@@ -22,6 +22,7 @@ export const PERMISSIONS = [
   "people:read",
   "people:write",
   "people:appoint",
+  "people:link",
   "esign:sign",
   "esign:requests:manage",
   "esign:drives:manage",
diff --git a/tests/people-access.test.mjs b/tests/people-access.test.mjs
index bdd0220..82d676c 100644
--- a/tests/people-access.test.mjs
+++ b/tests/people-access.test.mjs
@@ -14,83 +14,159 @@ registerHooks({
 
 const { fakePeopleApi } = await import("../src/features/people/people.fake.server.ts")
 
-const ALL = ["people:read", "people:write", "people:appoint", "people:self"]
+const ALL = ["people:read", "people:write", "people:appoint", "people:link", "people:self"]
 const SELF = ["people:self"]
-const hr = fakePeopleApi({ permissions: ALL, personId: null })
+const hr = fakePeopleApi({ permissions: ALL, personId: "P-0002" })
 const records = await Promise.all((await hr.listPeople()).map((person) => hr.getPerson(person.id)))
 
-const activeLead = (person) => person.teams.find((team) => team.role === "lead" && !team.endedOn)
-const plain = records.find((person) => !person.admin?.capoScope && !activeLead(person))
-const lead = records.find(activeLead)
-const teamId = activeLead(lead).team
+const current = (person, kind) => person.assignments.find((a) => a.kind === kind && a.endedOn === null)
+const leadOf = (person) => person.assignments.find((a) => a.teamRole === "lead" && a.endedOn === null)
+const capo = records.find((person) => current(person, "capo") && person.account.status === "linked")
+const plain = records.find(
+  (person) => !current(person, "capo") && !leadOf(person) && person.account.status === "linked"
+)
+const lead = records.find((person) => leadOf(person) && person.account.status === "linked" && person.id !== "P-0002")
+const teamId = leadOf(lead).team
 const teammate = records.find(
-  (person) => person.id !== lead.id && person.teams.some((team) => team.team === teamId && !team.endedOn)
+  (person) =>
+    person.id !== lead.id &&
+    person.assignments.some((a) => a.team === teamId && a.endedOn === null && a.teamRole === "member") &&
+    !person.assignments.some((a) => a.status === "sent")
 )
-const capo = records.find((person) => person.admin?.status === "active" && person.admin.capoScope)
 
 const unauthorized = { message: "UNAUTHORIZED" }
 
-void test("the Capo Admin area lists the admins who have the viewer as Capo Admin of reference", async () => {
+void test("agent mode covers linked and unlinked records and every assignment status", () => {
+  const accounts = new Set(records.map((person) => person.account.status))
+  assert.deepEqual([...accounts].sort(), ["invite", "linked", "none"])
+  const statuses = new Set(records.flatMap((person) => person.assignments.map((a) => a.status)))
+  assert.deepEqual([...statuses].sort(), ["applied", "pending", "refused", "sent"])
+  for (const person of records)
+    for (const assignment of person.assignments) {
+      // Pending means not linked: Auth knows nothing of the record yet.
+      if (assignment.status === "pending" && assignment.endedOn === null)
+        assert.notEqual(person.account.status, "linked", `${person.id} ${assignment.id}`)
+      if (assignment.status === "refused") assert.ok(assignment.refusal, `${person.id} ${assignment.id}`)
+    }
+  const today = new Date().toISOString().slice(0, 10)
+  const invites = records.flatMap((person) => (person.account.status === "invite" ? [person.account] : []))
+  assert.ok(
+    invites.some((invite) => invite.expiresOn < today),
+    "an expired invite"
+  )
+  assert.ok(
+    invites.some((invite) => invite.expiresOn >= today),
+    "an open invite"
+  )
+})
+
+void test("the Capo Admin area lists the admins who have the viewer as Capo Admin of reference, without contacts", async () => {
   const area = await fakePeopleApi({ permissions: SELF, personId: capo.id }).getCapoArea()
-  assert.equal(area.scope, capo.admin.capoScope)
+  assert.equal(area.scope, current(capo, "capo").capoScope)
   assert.ok(area.admins.length > 0, "the fixtures give the Capo Admin some admins")
   for (const admin of area.admins) {
-    assert.equal(admin.admin?.capoOfReference?.id, capo.id)
-    assert.equal(admin.profile.personalEmail, null)
+    assert.equal(current(admin, "admin")?.capoOfReference?.id, capo.id)
+    assert.equal(admin.contactEmail, null)
+    assert.equal(admin.phone, null)
   }
-  assert.deepEqual(Object.keys(area).sort(), ["admins", "scope"])
   await assert.rejects(fakePeopleApi({ permissions: SELF, personId: plain.id }).getCapoArea(), unauthorized)
   await assert.rejects(fakePeopleApi({ permissions: SELF, personId: "none" }).getCapoArea(), unauthorized)
 })
 
-void test("records carry no member, census, fee or Telegram group data", async () => {
-  for (const person of records) {
-    for (const key of ["member", "isMember", "census", "fees"]) assert.ok(!(key in person), `${person.id} has ${key}`)
-    if (person.admin) {
-      assert.ok(!("groups" in person.admin), person.id)
-      assert.ok(!("requested" in person.admin), person.id)
-    }
-    assert.notEqual(person.account.status, "review")
-  }
-})
-
-void test("ending a Lead role needs people:appoint, like giving it", async () => {
+void test("a Lead manages their team's members, but appointing or ending a Lead needs people:appoint", async () => {
   const asLead = fakePeopleApi({ permissions: SELF, personId: lead.id })
-  const end = (api, personId) =>
-    api.endTeamMembership({ teamId, personId, lastDay: "2026-10-14", reason: "Test", note: "" })
+  const end = (api, personId) => api.endTeamMembership({ teamId, personId, reason: "Test" })
 
-  await assert.rejects(end(asLead, lead.id), unauthorized)
+  // Nobody gives themselves a role, and a Lead is no Lead of Leads.
+  const otherTeam = ["it", "hr", "design", "intl"].find((team) => team !== teamId)
+  await assert.rejects(
+    asLead.addTeamMember({ teamId: otherTeam, personId: lead.id, role: "member", since: "2026-01-01", fields: {} }),
+    /give themselves/
+  )
   await assert.rejects(end(fakePeopleApi({ permissions: ["people:write"], personId: null }), lead.id), unauthorized)
   await end(asLead, teammate.id)
-  await end(hr, lead.id)
+  const after = await hr.getPerson(teammate.id)
+  const ended = after.assignments.find((a) => a.team === teamId && a.change === "end")
+  assert.ok(ended?.endedOn, "the membership ended")
+  assert.equal(ended.status, after.account.status === "linked" ? "sent" : "pending")
+  // Giving up one's own role is always allowed, as in Auth.
+  await end(asLead, lead.id)
+  assert.ok(leadOf(await hr.getPerson(lead.id)) === undefined, "the Lead role ended")
 })
 
-void test("a Lead sees contacts of current team members only", async () => {
-  // Earlier tests may end memberships, so pick the team from the current state.
-  const inTeam = (person, id) => person.teams.some((membership) => membership.team === id && !membership.endedOn)
-  const full = (await hr.listTeams()).find(
-    (candidate) => candidate.lead && candidate.members.some((person) => !inTeam(person, candidate.id))
+void test("a Lead's team lists the memberships in effect, pending ones of unlinked records included", async () => {
+  // A team whose Lead is linked and has a member whose record isn't: P-0030 leads Design & Marketing.
+  const designLead = records.find((person) => leadOf(person)?.team === "design")
+  const [design] = await fakePeopleApi({ permissions: SELF, personId: designLead.id }).listTeams()
+  assert.equal(design.id, "design")
+  const pending = records.find((person) =>
+    person.assignments.some((a) => a.team === "design" && a.endedOn === null && a.status === "pending")
   )
-  assert.ok(full, "the fixtures hold a team with a Lead and a former member")
-  const [team] = await fakePeopleApi({ permissions: SELF, personId: full.lead.id }).listTeams()
-  for (const person of team.members.filter((candidate) => !inTeam(candidate, team.id))) {
-    assert.equal(person.profile.phone, null)
-    assert.equal(person.profile.personalEmail, null)
+  assert.ok(pending, "the fixtures have an unlinked Design & Marketing member")
+  assert.ok(design.members.some((member) => member.id === pending.id))
+  for (const member of design.members) {
+    assert.ok(member.assignments.length > 0, member.id)
+    assert.ok(
+      member.assignments.every((a) => a.team === "design" && a.endedOn === null),
+      member.id
+    )
   }
-  const withPhone = full.members.find(
-    (person) => inTeam(person, team.id) && person.id !== full.lead.id && person.profile.phone
+})
+
+void test("Auth's refusal reaches the record and the caller", async () => {
+  const refusing = records.find((person) => person.account.status === "linked" && person.account.sub === "sub-0012")
+  await assert.rejects(
+    hr.addTeamMember({ teamId: "intl", personId: refusing.id, role: "member", since: "2026-01-01", fields: {} }),
+    /permissions/
+  )
+  const after = await hr.getPerson(refusing.id)
+  const refused = after.assignments.find((a) => a.team === "intl")
+  assert.equal(refused.status, "refused")
+  assert.ok(refused.endedOn, "a refused start never took effect")
+})
+
+void test("an unlinked record's new roles wait as pending, and go to Auth when it is linked", async () => {
+  const { id } = await hr.createPerson({
+    firstName: "Nuova",
+    lastName: "Persona",
+    contactEmail: "",
+    phone: "",
+    telegramUsername: "",
+  })
+  await hr.assignAdmin({ personId: id, since: "2026-01-01", capoId: null })
+  assert.equal(current(await hr.getPerson(id), "admin").status, "pending")
+  await hr.linkAccount({ personId: id, accountId: "sub-0105", reason: "Checked in person" })
+  const linked = await hr.getPerson(id)
+  assert.equal(linked.account.status, "linked")
+  assert.equal(current(linked, "admin").status, "sent")
+  // Roles waiting for Auth block another change, and the account can't be linked twice.
+  await assert.rejects(hr.unlinkAccount({ personId: id, reason: "Test" }), /waiting/)
+  await assert.rejects(hr.linkAccount({ personId: "P-0040", accountId: "sub-0105", reason: "Test" }), /already linked/)
+})
+
+void test("a team without a bound Lead role can't get a Lead, and only bound roles are offered", async () => {
+  const teams = await hr.listTeams()
+  const events = teams.find((team) => team.id === "events")
+  assert.equal(events.assignable.lead, false)
+  await assert.rejects(
+    hr.addTeamMember({ teamId: "events", personId: plain.id, role: "lead", since: "2026-01-01", fields: {} }),
+    /No role is bound/
   )
-  assert.ok(withPhone, "the fixtures hold a current teammate with a phone")
-  const activeRow = team.members.find((person) => person.id === withPhone.id)
-  assert.equal(activeRow.profile.phone, withPhone.profile.phone)
-  assert.equal(activeRow.profile.personalEmail, withPhone.profile.personalEmail)
+})
+
+void test("linking by hand and unlinking need people:link", async () => {
+  const writer = fakePeopleApi({ permissions: ["people:read", "people:write"], personId: null })
+  await assert.rejects(writer.searchAccounts({ query: "" }), unauthorized)
+  await assert.rejects(writer.unlinkAccount({ personId: plain.id, reason: "Test" }), unauthorized)
+  assert.ok((await hr.searchAccounts({ query: "gmail" })).length > 0)
 })
 
 void test("My area shows the record, or nothing yet for a sign-in without one", async () => {
-  const mine = await fakePeopleApi({ permissions: SELF, personId: lead.id }).getMyArea()
+  const mine = await fakePeopleApi({ permissions: SELF, personId: capo.id }).getMyArea()
   assert.equal(mine.state, "linked")
-  assert.deepEqual(Object.keys(mine).sort(), ["contacts", "person", "roster", "state"])
+  assert.equal(mine.person.id, capo.id)
+  assert.deepEqual(mine.person.activity, [], "the activity needs people:read")
   assert.equal(mine.person.notes, null)
-  const none = await fakePeopleApi({ permissions: SELF, personId: "none" }).getMyArea()
-  assert.deepEqual(none, { state: "none" })
+  assert.deepEqual(await fakePeopleApi({ permissions: SELF, personId: "none" }).getMyArea(), { state: "none" })
+  await assert.rejects(fakePeopleApi({ permissions: [], personId: capo.id }).getMyArea(), unauthorized)
 })
diff --git a/tests/people-input.test.mjs b/tests/people-input.test.mjs
index 58cb671..8870f2d 100644
--- a/tests/people-input.test.mjs
+++ b/tests/people-input.test.mjs
@@ -2,11 +2,17 @@ import assert from "node:assert/strict"
 import test from "node:test"
 
 import {
-  capoAreaSchema,
+  adminSummarySchema,
+  ASSIGNMENT_STATUSES,
+  assignmentSchema,
   linkAccountInputSchema,
   myAreaSchema,
+  newPersonInputSchema,
   personInputSchema,
   personRecordSchema,
+  TEAMS,
+  unlinkAccountInputSchema,
+  UNLINK_REASON,
 } from "../src/features/people/people.contract.ts"
 
 void test("People IDs, reasons and emails have bounded inputs", () => {
@@ -15,111 +21,118 @@ void test("People IDs, reasons and emails have bounded inputs", () => {
     false
   )
   assert.equal(
-    personInputSchema.pick({ personalEmail: true }).safeParse({ personalEmail: `${"a".repeat(250)}@example.org` })
+    personInputSchema.pick({ contactEmail: true }).safeParse({ contactEmail: `${"a".repeat(250)}@example.org` })
       .success,
     false
   )
+  // Auth takes a 500-character reason, and the backend prefixes it.
+  const reason = "x".repeat(500 - UNLINK_REASON.length)
+  assert.equal(unlinkAccountInputSchema.safeParse({ personId: "P-0001", reason }).success, true)
+  assert.equal(unlinkAccountInputSchema.safeParse({ personId: "P-0001", reason: `${reason}x` }).success, false)
 })
 
-// What the backend sends until its own cleanup (PoliNetworkOrg/backend#100) deploys.
-const legacyProfile = {
-  firstName: "Giulia",
-  lastName: "Rossi",
-  personalEmail: null,
-  phone: null,
-  telegramUsername: "giuliarossi",
-  telegramId: null,
-  course: "Ingegneria Informatica",
-  year: "2nd year",
-  campus: "Leonardo",
-  otherAssociations: [],
-  studentRepresentative: null,
+void test("a person needs only a name; contacts may be empty", () => {
+  const empty = { contactEmail: "", phone: "", telegramUsername: "" }
+  assert.deepEqual(personInputSchema.parse({ firstName: " Giulia ", lastName: "Rossi", ...empty }), {
+    firstName: "Giulia",
+    lastName: "Rossi",
+    ...empty,
+  })
+  assert.equal(personInputSchema.safeParse({ firstName: "", lastName: "Rossi", ...empty }).success, false)
+  assert.equal(
+    personInputSchema.parse({ firstName: "Giulia", lastName: "Rossi", ...empty, telegramUsername: "@giulia_r" })
+      .telegramUsername,
+    "giulia_r"
+  )
+})
+
+void test("Add person's roles: a Capo Admin is an admin too, and each team appears once", () => {
+  const person = { firstName: "Giulia", lastName: "Rossi", contactEmail: "", phone: "", telegramUsername: "" }
+  const valid = { ...person, admin: true, capoScope: "Informatica", teams: [{ team: "it", role: "member" }] }
+  assert.equal(newPersonInputSchema.safeParse(valid).success, true)
+  assert.equal(newPersonInputSchema.safeParse({ ...valid, admin: false }).success, false)
+  assert.equal(
+    newPersonInputSchema.safeParse({
+      ...valid,
+      teams: [
+        { team: "it", role: "member" },
+        { team: "it", role: "lead" },
+      ],
+    }).success,
+    false
+  )
+  // Only the predetermined kinds: no other role can be named.
+  assert.equal(newPersonInputSchema.safeParse({ ...valid, teams: [{ team: "board", role: "member" }] }).success, false)
+  assert.equal(newPersonInputSchema.safeParse({ ...valid, teams: [{ team: "it", role: "owner" }] }).success, false)
+})
+
+const assignment = {
+  id: "A-1",
+  kind: "admin",
+  team: null,
+  teamRole: null,
+  capoScope: null,
+  capoOfReference: { id: "P-0007", name: "Giulia Rossi" },
+  fields: {},
+  since: "2026-01-10",
+  endedOn: null,
+  endReason: null,
+  assignedBy: "sub-0002",
+  change: "start",
+  status: "refused",
+  refusal: "The actor can't give a role with permissions they don't hold",
 }
-const legacyRecord = {
-  id: "P-0142",
-  profile: legacyProfile,
-  member: { number: "0290", status: "active", admittedOn: "2024-10-01", fee: "paid", m365Email: "g@polinetwork.org" },
-  isMember: true,
-  admin: {
-    status: "active",
-    since: "2024-10-03",
-    endedOn: null,
-    endReason: null,
-    groups: [{ chatId: "-1001", title: "Basi di Dati" }],
-    requested: [{ chatId: "-1002", title: "Reti Logiche", requestedOn: "2026-10-09" }],
-    availableAsCapo: true,
-    capoOfReference: null,
-    capoScope: null,
-  },
-  teams: [],
-  census: [{ year: "2026/27", answer: null, answeredOn: null, source: null, declaredMember: null, reminders: 1 }],
-  consents: { privacy: null, photo: null },
-  account: { status: "review", reviewId: "r1", issue: "Telegram account already linked to another record" },
-  notes: null,
-  discrepancies: [{ kind: "declared-member", message: "Declared a member", suggestedTelegram: null }],
-  activity: [],
-  fees: { current: null, receipts: [] },
+const row = {
+  id: "P-0012",
+  firstName: "Luca",
+  lastName: "Bianchi",
+  contactEmail: null,
+  phone: null,
+  telegramUsername: "lucab",
+  account: { status: "linked", sub: "sub-0012", method: "invite", linkedOn: "2026-10-01", linkedBy: "sub-0012" },
+  assignments: [assignment],
 }
 
-void test("records from the current backend parse, dropping what People no longer shows", () => {
-  const record = personRecordSchema.parse(legacyRecord)
-  for (const key of ["member", "isMember", "census", "fees"]) assert.ok(!(key in record), key)
-  assert.ok(!("groups" in record.admin))
-  assert.ok(!("requested" in record.admin))
-  // Record matching is gone: a record held for review reads as not linked.
-  assert.deepEqual(record.account, { status: "none" })
-  assert.equal(record.discrepancies[0].kind, "declared-member")
+void test("records from the Phase 1 backend parse, with each assignment's status and Auth's refusal", () => {
+  const record = personRecordSchema.parse({
+    ...row,
+    notes: null,
+    activity: [],
+    createdBy: "sub-0002",
+    createdAt: "2026-01-10T09:00:00.000Z",
+    updatedBy: "sub-0002",
+    updatedAt: "2026-01-10T09:00:00.000Z",
+  })
+  assert.equal(record.assignments[0].status, "refused")
+  assert.equal(record.assignments[0].refusal, assignment.refusal)
+  assert.equal(
+    adminSummarySchema.parse({ person: row, admin: assignment, capo: null }).admin.capoOfReference.id,
+    "P-0007"
+  )
+  for (const status of ASSIGNMENT_STATUSES)
+    assert.equal(assignmentSchema.safeParse({ ...assignment, status }).success, true)
+  assert.equal(assignmentSchema.safeParse({ ...assignment, status: "review" }).success, false)
 })
 
-void test("My area from the current backend parses, and a first-sign-in match reads as no record", () => {
+void test("My area parses a linked record or no record", () => {
+  assert.deepEqual(myAreaSchema.parse({ state: "none" }), { state: "none" })
   const linked = myAreaSchema.parse({
     state: "linked",
-    person: legacyRecord,
-    feeInstructions: { beneficiary: "PoliNetwork", iban: "IT00", reference: "Quota" },
-    campaign: { id: "2026", year: "2026/27", closesOn: "2026-10-31" },
-    contacts: [{ role: "hr", name: "HR team", telegram: null, email: "hr@polinetwork.org", team: null }],
-    roster: {
-      team: "it",
-      members: [{ id: "P-0142", name: "Giulia Rossi", role: "member", telegram: null, email: "g@polinetwork.org" }],
+    person: {
+      ...row,
+      notes: null,
+      activity: [],
+      createdBy: "auth",
+      createdAt: "2026-01-10T09:00:00.000Z",
+      updatedBy: "auth",
+      updatedAt: "2026-01-10T09:00:00.000Z",
     },
+    contacts: [{ role: "hr", name: "Sara Colombo", telegram: null, team: "hr" }],
+    roster: null,
   })
   assert.equal(linked.state, "linked")
-  assert.ok(!("feeInstructions" in linked))
-  assert.ok(!("campaign" in linked))
-  assert.ok(!("email" in linked.contacts[0]))
-  assert.ok(!("email" in linked.roster.members[0]))
-  // The old backend's "none" carries the request to be added; the new one sends the state alone.
-  assert.deepEqual(myAreaSchema.parse({ state: "none", request: { sentOn: "2026-10-01" } }), { state: "none" })
-  assert.deepEqual(myAreaSchema.parse({ state: "none" }), { state: "none" })
-  const match = myAreaSchema.parse({
-    state: "match",
-    candidate: { id: "P-0142", name: "Giulia Rossi", course: "", year: "", campus: "Leonardo", roles: [] },
-    reason: "Matched on your email address.",
-  })
-  assert.deepEqual(match, { state: "none" })
-})
-
-void test("the Capo area from the current backend parses without its Telegram groups and join requests", () => {
-  const area = capoAreaSchema.parse({
-    scope: "Informatica",
-    groups: [{ chatId: "-1001", title: "Analisi 1", admins: null }],
-    admins: [],
-    requests: [],
-  })
-  assert.deepEqual(area, { scope: "Informatica", admins: [] })
 })
 
-void test("records from the cleaned-up backend parse without the dropped fields", () => {
-  const { member, isMember, census, fees, ...rest } = legacyRecord
-  const { groups, requested, ...admin } = legacyRecord.admin
-  void [member, isMember, census, fees, groups, requested]
-  const record = personRecordSchema.parse({
-    ...rest,
-    admin,
-    account: { status: "none" },
-    discrepancies: [{ kind: "needs-review", message: "Check the sign-in", suggestedTelegram: null }],
-  })
-  assert.equal(record.admin.availableAsCapo, true)
-  assert.equal(record.discrepancies[0].kind, "needs-review")
-  assert.deepEqual(capoAreaSchema.parse({ scope: "Informatica", admins: [] }), { scope: "Informatica", admins: [] })
+void test("the Design team is called Design & Marketing", () => {
+  assert.equal(TEAMS.design.name, "Design & Marketing")
 })
diff --git a/tests/server-security.test.mjs b/tests/server-security.test.mjs
index d17b3fa..4e57473 100644
--- a/tests/server-security.test.mjs
+++ b/tests/server-security.test.mjs
@@ -222,6 +222,8 @@ test("dashboard server functions attach their scoped authorization middleware",
     "src/features/people/people-teams.functions.ts",
     "src/features/people/people-capo.functions.ts",
     "src/features/people/people-self.functions.ts",
+    "src/features/people/people-invites.functions.ts",
+    "src/features/people/people-link.functions.ts",
   ]
 
   for (const file of adminFunctionFiles) {
@@ -233,7 +235,7 @@ test("dashboard server functions attach their scoped authorization middleware",
       assert.ok(
         serverFunction.middleware.includes("adminMiddleware") ||
           serverFunction.middleware.some((name) =>
-            /(?:Read|Write|Manage|Create|Self|Appoint|Sign)Middleware$/.test(name)
+            /(?:Read|Write|Manage|Create|Self|Appoint|Link|Sign)Middleware$/.test(name)
           ),
         `${file}:${serverFunction.name} must authorize access`
       )
@@ -267,7 +269,11 @@ test("dashboard mutations enforce their exact write scope", async () => {
     ["reportsManageMiddleware", ["src/features/group-link-reports/reports.functions.ts"]],
     ["peopleWriteMiddleware", ["src/features/people/people-write.functions.ts"]],
     ["peopleAppointMiddleware", ["src/features/people/people-appoint.functions.ts"]],
-    ["peopleTeamWriteMiddleware", ["src/features/people/people-teams.functions.ts"]],
+    [
+      "peopleTeamWriteMiddleware",
+      ["src/features/people/people-teams.functions.ts", "src/features/people/people-invites.functions.ts"],
+    ],
+    ["peopleLinkMiddleware", ["src/features/people/people-link.functions.ts"]],
     ["peopleSelfMiddleware", ["src/features/people/people-self.functions.ts"]],
   ].map(([expectedMiddleware, files]) => ({ expectedMiddleware, files }))
 
@@ -321,8 +327,9 @@ test("dashboard mutation controls use their server's write scope", async () => {
     "src/features/guides/guides-page.tsx": "web:content:write",
     "src/features/freshman/freshman-page.tsx": "web:content:write",
     "src/features/projects/projects-page.tsx": "web:content:write",
-    "src/features/people/overview-page.tsx": "people:write",
-    "src/features/people/person-page.tsx": ["people:write", "people:read", "people:appoint"],
+    "src/features/people/overview-page.tsx": ["people:write", "people:link"],
+    "src/features/people/person-page.tsx": ["people:write", "people:read", "people:appoint", "people:link"],
+    "src/features/people/person-dialog.tsx": "people:appoint",
     "src/features/people/admins-page.tsx": ["people:write", "people:appoint"],
     "src/features/people/teams-page.tsx": ["people:read", "people:write", "people:appoint"],
     "src/features/people/linking-page.tsx": "people:write",
@@ -368,13 +375,19 @@ test("event handlers integrate protected server-function redirects with the rout
     "src/features/azure/member-dialog.tsx": ["createAzureMember"],
     "src/features/azure/member-number-dialog.tsx": ["setAzureMemberNumber"],
     "src/features/people/person-dialog.tsx": ["createPerson", "updatePerson"],
-    "src/features/people/person-page.tsx": ["updatePerson"],
     "src/features/people/notes-dialog.tsx": ["setPersonNote"],
-    "src/features/people/account-action-dialog.tsx": ["sendPersonInvite", "revokePersonInvite", "unlinkPersonAccount"],
-    "src/features/people/link-account-dialog.tsx": ["linkPersonAccount"],
+    "src/features/people/account-action-dialog.tsx": ["sendPersonInvite", "revokePersonInvite"],
+    "src/features/people/link-account-dialog.tsx": ["linkPersonAccount", "unlinkPersonAccount"],
     "src/features/people/my-area-page.tsx": ["acceptMyInvite"],
     "src/features/people/team-dialogs.tsx": ["addTeamMember", "updateTeamFields", "endTeamMembership"],
-    "src/features/people/admin-dialogs.tsx": ["endAdminRole", "setCapoOfReference", "setCapoScope"],
+    "src/features/people/admin-dialogs.tsx": [
+      "assignAdmin",
+      "endAdminRole",
+      "setCapoOfReference",
+      "appointCapo",
+      "setCapoScope",
+      "endCapo",
+    ],
     "src/features/esign/new-request-page.tsx": [
       "uploadEsignDocument",
       "importEsignDriveDocument",