From fd85b17a00c48f6698df63f8f50b7f696950843a Mon Sep 17 00:00:00 2001
From: mindsers <nathanael@cherrier.dev>
Date: Mon, 31 Aug 2026 21:00:19 +0200
Subject: [PATCH 1/2] feat(publishers)!: drop the Member.type column
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Final step: PioneerEnrolment has been the source of truth for a member's standing
pioneer status since the plan/actual split, and the previous release moved every
reader onto the stints and backfilled anyone holding a type without one. This
removes what nothing reads any more, plus the CHECK constraint that referenced it
(dropped first, or the column drop fails on the dependency).

Two behaviours had to be translated rather than deleted, because the column was
carrying them:

Turning off the permanent-auxiliary profile used to flip every auxiliary member's
cached type. It now closes their ongoing auxiliary stints at the current month via
endOngoingEnrolmentsOfType — the same intent against the source of truth, and it
keeps the history of what they actually did. The old version was already incoherent:
it flipped the cache and left the stints open, so the two disagreed immediately.

Filtering the publisher list by type now filters on stints — an ongoing stint of
that type, or for Normal the absence of one. A single-month auxiliary is closed, so
it still reads as Normal, exactly as the column did.

The create form no longer offers a pioneer type. A pioneer appointment is an
enrolment with a period, made from the pioneer section of the edit page, which is
where the edit form already sent people. The form schemas drop the field, so a
member is created Normal and appointed afterwards.

Also: the S-21 export and the group roster derive the status from the stints; the
archive export stops emitting the field and the importer ignores it on older
archives; the activity-derived backfill loses its `memberType` fallback, so
contiguous auxiliary months now backfill as single-month stints — the snapshots
cannot distinguish a monthly auxiliary from a permanent one, and single-month is the
safe guess because it grants no standing status.

Three readers were invisible to the compiler and only failed at runtime: a `where`
clause inside an `OR`, a spread-built filter, and a spread `select`. They were found
by applying the migration locally and running the whole suite against a database
without the column, which is the only check that catches this class.
---
 .../migration.sql                             |  14 +++
 ...ing-pioneer-enrolments.integration.test.ts |  35 +++++-
 .../drop-member-type.integration.test.ts      |  60 ++++++++++
 app/database/schema.prisma                    |   6 +-
 ...mic-documents-inactive.integration.test.ts |   2 -
 .../dynamic-documents.integration.test.ts     |   1 -
 .../server/dynamic-documents.server.ts        |   2 +-
 .../ui/dynamic/PublisherGroupsView.tsx        |   2 +-
 .../routes/programs/events/publisher-info.tsx |   5 +-
 app/features/publishers/index.server.ts       |   8 +-
 .../publishers/routes/activity/new.tsx        |  17 ++-
 .../routes/publishers/edit-publisher.tsx      |   9 +-
 .../routes/publishers/new-publisher.tsx       |  15 +--
 .../schemas/edit-publisher.schema.ts          |   2 -
 .../schemas/publisher.schema.test.ts          |  19 ++-
 .../publishers/schemas/publisher.schema.ts    |   2 -
 .../publishers/server/member-identity.test.ts |   6 -
 .../publishers/server/member-identity.ts      |   7 --
 ...r-preconditions.server.integration.test.ts |   4 -
 .../member.aggregate.integration.test.ts      |  70 +----------
 .../publishers/server/member.aggregate.ts     |  52 ---------
 .../pioneer-activity.integration.test.ts      |   1 -
 .../server/pioneer-activity.queries.test.ts   |   2 +-
 .../server/pioneer-activity.queries.ts        |  15 ++-
 ...olment-backfill.server.integration.test.ts |  16 +--
 .../pioneer-enrolment-backfill.server.test.ts |  29 +++--
 .../pioneer-enrolment-backfill.server.ts      |  19 +--
 ...er-enrolment.aggregate.integration.test.ts |   3 +-
 ...neer-enrolment.queries.integration.test.ts |   2 +-
 ...eer-enrolment.workflow.integration.test.ts | 110 ++++++++++++++----
 .../server/pioneer-enrolment.workflow.ts      |  68 +++++++----
 .../server/publishers.server.test.ts          |   6 +-
 .../publishers/server/publishers.server.ts    |  14 ++-
 .../server/render-activity-pdf-zip.server.tsx |   7 +-
 .../update-member.server.integration.test.ts  |   1 -
 .../server/update-member.server.test.ts       |   4 -
 .../ui/PublisherActivityDocument.tsx          |  13 ++-
 .../ui/PublisherFieldServiceForm.tsx          |  49 +-------
 .../routes/users/add-to-congregation.tsx      |   2 -
 .../congregation-settings.server.test.ts      |  69 +++--------
 .../server/congregation-settings.server.ts    |  17 +--
 .../server/export-congregation.server.ts      |   1 -
 .../server/import-user-accounts.server.ts     |   2 -
 .../server/link-member-to-account.server.ts   |   3 -
 .../migrate-legacy-users-ndjson.server.ts     |   1 -
 .../built-in-roles.server.integration.test.ts |  12 +-
 46 files changed, 398 insertions(+), 406 deletions(-)
 create mode 100644 app/database/migrations/20260831230000_drop_member_type/migration.sql
 create mode 100644 app/database/migrations/drop-member-type.integration.test.ts

diff --git a/app/database/migrations/20260831230000_drop_member_type/migration.sql b/app/database/migrations/20260831230000_drop_member_type/migration.sql
new file mode 100644
index 00000000..7a3991d4
--- /dev/null
+++ b/app/database/migrations/20260831230000_drop_member_type/migration.sql
@@ -0,0 +1,14 @@
+-- Drops `Member.type`. It cached a member's standing pioneer status; PioneerEnrolment is the source
+-- of truth for the same fact and has been since the plan/actual split. The preceding release moved
+-- every reader onto the stints and backfilled the members who had a type but no stint, so this file
+-- only removes what nothing reads any more.
+--
+-- Contract: no change in who is a pioneer. Anyone whose status came from this column already has an
+-- ongoing stint carrying it.
+--
+-- The CHECK constraint has to go first — it references the column, so the DROP COLUMN would fail on
+-- a dependency error rather than cascading.
+
+ALTER TABLE "Member" DROP CONSTRAINT IF EXISTS "member_pioneer_requires_baptism";
+
+ALTER TABLE "Member" DROP COLUMN "type";
diff --git a/app/database/migrations/backfill-standing-pioneer-enrolments.integration.test.ts b/app/database/migrations/backfill-standing-pioneer-enrolments.integration.test.ts
index d8527c8f..03d9cbf7 100644
--- a/app/database/migrations/backfill-standing-pioneer-enrolments.integration.test.ts
+++ b/app/database/migrations/backfill-standing-pioneer-enrolments.integration.test.ts
@@ -27,6 +27,26 @@ function migrationStatements(): string[] {
     .filter(statement => statement.length > 0)
 }
 
+// A later migration drops `Member.type`, so by the time this test runs against a migrated database
+// the column this backfill reads is gone. Recreate a minimal stand-in — `IF NOT EXISTS` makes it a
+// no-op on a database where the drop has not been applied, so the test behaves identically in both.
+// The PublisherType enum itself survives — PioneerEnrolment and PublisherActivity still use it —
+// and the stand-in must BE that enum: the migration selects this column straight into
+// PioneerEnrolment.type, which a text column cannot satisfy.
+// Prisma's client speaks the enum NAMES; the database stores the `@map`-ed values. Raw SQL needs
+// the latter, and the mapping is only in schema.prisma, so it is spelled out here.
+const DB_ENUM_VALUE: Record<PublisherType, string> = {
+  [PublisherType.Normal]: 'normal',
+  [PublisherType.PionnierAuxiliaires]: 'pionnier-auxiliaires',
+  [PublisherType.PionnierPermanant]: 'pionnier-permanant',
+  [PublisherType.PionnierSpecial]: 'pionnier-special',
+  [PublisherType.Missionnaire]: 'missionnaire',
+}
+
+const RECREATE_DROPPED_COLUMN = `
+  ALTER TABLE "Member" ADD COLUMN IF NOT EXISTS "type" "PublisherType" NOT NULL DEFAULT 'normal'
+`
+
 /** Thrown to roll the fixture back; every assertion runs on captured values. */
 class Rollback extends Error {}
 
@@ -71,23 +91,32 @@ async function execute(): Promise<Captured> {
     await testDb.$transaction(
       async tx => {
         const stamp = `mig-${process.pid}-${globalThis.performance.now().toString().replace('.', '')}`
+        await tx.$executeRawUnsafe(RECREATE_DROPPED_COLUMN)
         const congregation = await tx.congregation.create({ data: { name: stamp, slug: stamp, active: true } })
         const congregationId = congregation.id
 
         // baptismDate is not optional here: a `member_pioneer_requires_baptism` CHECK constraint
         // means a pioneer-typed row cannot exist without one, which also bounds the population this
         // migration can ever see.
-        const makeMember = (firstname: string, type: PublisherType) =>
-          tx.member.create({
+        // Prisma no longer knows the column a later migration dropped, so the fixture writes it
+        // in raw SQL against the stand-in recreated above.
+        const makeMember = async (firstname: string, type: PublisherType) => {
+          const member = await tx.member.create({
             data: {
               firstname,
               lastname: stamp,
               isPublisher: true,
-              type,
               baptismDate: new Date('2015-01-01'),
               congregationId,
             },
           })
+          await tx.$executeRawUnsafe(
+            'UPDATE "Member" SET "type" = $1::"PublisherType" WHERE "id" = $2',
+            DB_ENUM_VALUE[type],
+            member.id,
+          )
+          return member
+        }
 
         // Has reported activity — the stint should start at their EARLIEST reported month.
         const withActivity = await makeMember('WithActivity', PublisherType.PionnierPermanant)
diff --git a/app/database/migrations/drop-member-type.integration.test.ts b/app/database/migrations/drop-member-type.integration.test.ts
new file mode 100644
index 00000000..af707396
--- /dev/null
+++ b/app/database/migrations/drop-member-type.integration.test.ts
@@ -0,0 +1,60 @@
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { PrismaPg } from '@prisma/adapter-pg'
+import { afterAll, describe, expect, it } from 'vitest'
+import { PrismaClient } from '~/database/generated/client'
+
+// Runs against DB_URL rather than DB_RUNTIME_URL: a migration executes as the schema owner.
+const adapter = new PrismaPg({ connectionString: process.env.DB_URL, max: 3, connectionTimeoutMillis: 5000 })
+const testDb = new PrismaClient({ adapter })
+
+// Hoisted: a regex literal inside a function body is a lint error in this repo.
+const DROP_COLUMN_RE = /DROP COLUMN "type"/
+const DROP_CONSTRAINT_RE = /DROP CONSTRAINT IF EXISTS "member_pioneer_requires_baptism"/
+const ALTER_TABLE_RE = /ALTER TABLE "(\w+)"/g
+
+const MIGRATION_SQL = resolve(import.meta.dirname, '20260831230000_drop_member_type', 'migration.sql')
+
+function migrationSql(): string {
+  return readFileSync(MIGRATION_SQL, 'utf8')
+}
+
+function migrationStatements(): string[] {
+  return migrationSql()
+    .split('\n')
+    .filter(line => !line.trimStart().startsWith('--'))
+    .join('\n')
+    .split(';')
+    .map(statement => statement.trim())
+    .filter(statement => statement.length > 0)
+}
+
+afterAll(async () => {
+  await testDb.$disconnect()
+})
+
+describe('drop Member.type (migration)', () => {
+  // Not executed here. DROP COLUMN takes ACCESS EXCLUSIVE on Member and every table whose foreign
+  // keys reference it, held until rollback — running it in a fixture deadlocks unrelated suites at
+  // random. The shape of the file is what this asserts; that it applies cleanly is proved by CI
+  // running `prisma migrate deploy` against a fresh database before any test executes.
+  it('drops the dependent CHECK constraint before the column', () => {
+    const statements = migrationStatements()
+    const constraintIndex = statements.findIndex(s => s.includes('member_pioneer_requires_baptism'))
+    const columnIndex = statements.findIndex(s => DROP_COLUMN_RE.test(s))
+
+    expect(constraintIndex).toBeGreaterThanOrEqual(0)
+    expect(columnIndex).toBeGreaterThanOrEqual(0)
+    // Postgres refuses to drop a column a constraint still references, so the order is load-bearing.
+    expect(constraintIndex).toBeLessThan(columnIndex)
+  })
+
+  it('drops the constraint idempotently', () => {
+    expect(migrationSql()).toMatch(DROP_CONSTRAINT_RE)
+  })
+
+  it('touches only Member', () => {
+    const tables = [...migrationSql().matchAll(ALTER_TABLE_RE)].map(match => match[1])
+    expect([...new Set(tables)]).toEqual(['Member'])
+  })
+})
diff --git a/app/database/schema.prisma b/app/database/schema.prisma
index fb007e32..3bdb4c0c 100644
--- a/app/database/schema.prisma
+++ b/app/database/schema.prisma
@@ -174,10 +174,10 @@ model Member {
   dpaCardUpToDate       Boolean @default(false)
   survivalBackpackReady Boolean @default(false)
 
-  // Domain status. `isPublisher = false` means ministry-school student.
-  // `type` is only meaningful when `isPublisher = true`.
+  // Domain status. `isPublisher = false` means ministry-school student. Whether a publisher is a
+  // pioneer is NOT stored here — it is their PioneerEnrolment stints, so that a standing status and
+  // the period it covers cannot disagree.
   isPublisher Boolean       @default(false)
-  type        PublisherType @default(Normal)
   baptismDate DateTime?
   isAnointed  Boolean       @default(false)
   isHelder    Boolean       @default(false)
diff --git a/app/features/display-board/server/dynamic-documents-inactive.integration.test.ts b/app/features/display-board/server/dynamic-documents-inactive.integration.test.ts
index fb4efddd..6438ba57 100644
--- a/app/features/display-board/server/dynamic-documents-inactive.integration.test.ts
+++ b/app/features/display-board/server/dynamic-documents-inactive.integration.test.ts
@@ -54,7 +54,6 @@ beforeAll(async () => {
         firstname: 'Active',
         lastname: 'Pioneer',
         isPublisher: true,
-        type: PublisherType.PionnierPermanant,
         baptismDate: new Date('2010-01-01'),
         congregationId,
       },
@@ -66,7 +65,6 @@ beforeAll(async () => {
         firstname: 'Inactive',
         lastname: 'Pioneer',
         isPublisher: true,
-        type: PublisherType.PionnierPermanant,
         baptismDate: new Date('2010-01-01'),
         inactiveAt: new Date('2026-01-01'),
         congregationId,
diff --git a/app/features/display-board/server/dynamic-documents.integration.test.ts b/app/features/display-board/server/dynamic-documents.integration.test.ts
index 5e0c1d5d..73c12fe2 100644
--- a/app/features/display-board/server/dynamic-documents.integration.test.ts
+++ b/app/features/display-board/server/dynamic-documents.integration.test.ts
@@ -59,7 +59,6 @@ beforeAll(async () => {
         lastname: 'Martin',
         baptismDate: new Date('2010-01-01'),
         isPublisher: true,
-        type: PublisherType.PionnierPermanant,
         congregationId,
       },
     })
diff --git a/app/features/display-board/server/dynamic-documents.server.ts b/app/features/display-board/server/dynamic-documents.server.ts
index 1fdb6169..3ac2696e 100644
--- a/app/features/display-board/server/dynamic-documents.server.ts
+++ b/app/features/display-board/server/dynamic-documents.server.ts
@@ -367,7 +367,7 @@ function fetchPublisherGroups(db: TransactionClient, congregationId: number) {
       deputy: { select: userSelect },
       members: {
         where: { leftAt: null, isPublisher: true, inactiveAt: null },
-        select: { ...userSelect, type: true },
+        select: userSelect,
         orderBy: [{ lastname: 'asc' }, { firstname: 'asc' }],
       },
     },
diff --git a/app/features/display-board/ui/dynamic/PublisherGroupsView.tsx b/app/features/display-board/ui/dynamic/PublisherGroupsView.tsx
index 06f07ee8..d94df2d1 100644
--- a/app/features/display-board/ui/dynamic/PublisherGroupsView.tsx
+++ b/app/features/display-board/ui/dynamic/PublisherGroupsView.tsx
@@ -19,7 +19,7 @@ interface PublisherGroupsViewData {
     adress: string
     responsible: Person
     deputy: (Person & { id: number }) | null
-    members: (Person & { type: string })[]
+    members: Person[]
   }[]
 }
 
diff --git a/app/features/events/routes/programs/events/publisher-info.tsx b/app/features/events/routes/programs/events/publisher-info.tsx
index 4fa9b393..d083bff7 100644
--- a/app/features/events/routes/programs/events/publisher-info.tsx
+++ b/app/features/events/routes/programs/events/publisher-info.tsx
@@ -2,6 +2,7 @@ import { EventTemplateKey } from '~/features/events/model/event-template.type'
 import type { PartSlot } from '~/features/events/server/cadence-shared.server'
 import { listUserSameEventAssignments } from '~/features/events/server/list-user-same-event-assignments.server'
 import { resolvePublisherCadence } from '~/features/events/server/resolve-publisher-cadence.server'
+import { standingTypeFromEnrolments } from '~/features/publishers'
 import { currentAccountContext, permissionsContext, withScopeFromContext } from '~/shared/auth/route-context.server'
 import { Permission } from '~/shared/types/permission'
 import { formatGroupName } from '~/shared/utils/format-group-name'
@@ -42,7 +43,7 @@ export function loader({ request, params, context }: Route.LoaderArgs) {
     // Publisher profile
     const user = await db.member.findFirst({
       where: { id: userId, congregationId },
-      include: { publisherGroup: true, account: { select: { id: true } } },
+      include: { publisherGroup: true, account: { select: { id: true } }, pioneerEnrolments: true },
     })
     if (!user) return Response.json(null)
 
@@ -85,7 +86,7 @@ export function loader({ request, params, context }: Route.LoaderArgs) {
         lastname: user.lastname,
         isHelder: user.isHelder,
         isServant: user.isServant,
-        type: user.type,
+        type: standingTypeFromEnrolments(user.pioneerEnrolments),
         group: user.publisherGroup ? formatGroupName(user.publisherGroup.name) : null,
       },
       daysOff: daysOff.map(d => ({
diff --git a/app/features/publishers/index.server.ts b/app/features/publishers/index.server.ts
index f8570f96..50f5657b 100644
--- a/app/features/publishers/index.server.ts
+++ b/app/features/publishers/index.server.ts
@@ -9,7 +9,13 @@ export {
   getEnrolmentsForServiceYear,
   resolveEnrolmentMonthlyGoal,
 } from './server/pioneer-enrolment.queries'
-export { endPioneerEnrolment, enrolPioneer, removePioneerEnrolment } from './server/pioneer-enrolment.workflow'
+export {
+  endOngoingEnrolmentsOfType,
+  endPioneerEnrolment,
+  enrolPioneer,
+  removePioneerEnrolment,
+  updatePioneerEnrolment,
+} from './server/pioneer-enrolment.workflow'
 export { backfillCongregationEnrolments } from './server/pioneer-enrolment-backfill.server'
 export { listPioneerGoalsForYear, type PioneerGoalRow, resolvePioneerGoal } from './server/pioneer-goals.queries'
 export { getPublishers } from './server/publishers.server'
diff --git a/app/features/publishers/routes/activity/new.tsx b/app/features/publishers/routes/activity/new.tsx
index e3ea28ec..2d64da2a 100644
--- a/app/features/publishers/routes/activity/new.tsx
+++ b/app/features/publishers/routes/activity/new.tsx
@@ -4,7 +4,7 @@ import { useState } from 'react'
 import { data, Form, redirect, useSearchParams } from 'react-router'
 import { commitSession, getSession } from '~/features/authentication/index.server'
 import { getEnrolmentsForMember, resolveEnrolmentMonthlyGoal } from '~/features/publishers/index.server'
-import { enrolmentForMonth } from '~/features/publishers/model/pioneer-enrolment'
+import { enrolmentForMonth, standingTypeFromEnrolments } from '~/features/publishers/model/pioneer-enrolment'
 import { toServiceYear } from '~/features/publishers/model/pioneer-pace'
 import { createActivitySchema } from '~/features/publishers/schemas/activity.schema'
 import { createPublisherActivity } from '~/features/publishers/server/publisher-activity-mutations.server'
@@ -84,16 +84,20 @@ export function loader({ request, context }: Route.LoaderArgs) {
     }
 
     // Show the enrolled goal as read-only context so the report can be entered against the plan.
+    // `standingType` is the member's current status, derived from their stints — the form uses it to
+    // decide whether to offer the auxiliary-pioneer picker at all.
     let enrolmentGoal: number | null = null
+    let standingType: PublisherType = PublisherType.Normal
     if (publisher != null) {
       const enrolments = await getEnrolmentsForMember(db, publisher.id, currentUser.congregationId)
+      standingType = standingTypeFromEnrolments(enrolments)
       const active = enrolmentForMonth(enrolments, month, year)
       if (active != null) enrolmentGoal = await resolveEnrolmentMonthlyGoal(db, active, toServiceYear(month, year))
     }
 
     return {
       publishers,
-      publisher,
+      publisher: publisher == null ? null : { ...publisher, standingType },
       selectedMonth: { month, year },
       enrolmentGoal,
       previousPage: request.headers.get('referer'),
@@ -105,7 +109,7 @@ export default function NewActivity({ loaderData, actionData }: Route.ComponentP
   const { publishers, publisher, selectedMonth, enrolmentGoal, previousPage } = loaderData
   const [searchParams, setSearchParams] = useSearchParams()
   const [pioneer, setPioneer] = useState<PublisherType | null>(
-    publisher?.type === PublisherType.PionnierAuxiliaires ? PublisherType.PionnierAuxiliaires : null,
+    publisher?.standingType === PublisherType.PionnierAuxiliaires ? PublisherType.PionnierAuxiliaires : null,
   )
   const { blocker, markDirty } = useUnsavedChanges()
 
@@ -240,7 +244,7 @@ export default function NewActivity({ loaderData, actionData }: Route.ComponentP
               </p>
             )}
 
-            {publisher?.type != null && publisher.type === PublisherType.Normal && (
+            {publisher != null && publisher.standingType === PublisherType.Normal && (
               <div className="space-y-2">
                 <Label htmlFor="type">{m.activity_new_pioneer_label()}</Label>
                 <Select
@@ -269,7 +273,7 @@ export default function NewActivity({ loaderData, actionData }: Route.ComponentP
                   PublisherType.PionnierSpecial,
                   PublisherType.Missionnaire,
                 ] as PublisherType[]
-              ).includes(publisher?.type ?? PublisherType.Normal) ||
+              ).includes(publisher?.standingType ?? PublisherType.Normal) ||
               (pioneer != null && ([PublisherType.PionnierAuxiliaires] as PublisherType[]).includes(pioneer)) ? (
                 <div className="space-y-2">
                   <Label htmlFor={fields.hours.id}>{m.activity_new_hours_label()}</Label>
@@ -360,9 +364,10 @@ export async function action({ request, context }: Route.ActionArgs) {
     // (a Normal member reporting an auxiliary month without a formal enrolment).
     const enrolments = await getEnrolmentsForMember(db, publisher.id, currentUser.congregationId)
     const enrolledType = enrolmentForMonth(enrolments, month, year)?.type
+    const standingType = standingTypeFromEnrolments(enrolments)
     const type =
       enrolledType ??
-      (publisher.type === PublisherType.Normal ? (submission.value.type ?? PublisherType.Normal) : publisher.type)
+      (standingType === PublisherType.Normal ? (submission.value.type ?? PublisherType.Normal) : standingType)
     const activity = await createPublisherActivity(db, {
       publisherId: publisher.id,
       month,
diff --git a/app/features/publishers/routes/publishers/edit-publisher.tsx b/app/features/publishers/routes/publishers/edit-publisher.tsx
index 839ee0c9..4bdd447b 100644
--- a/app/features/publishers/routes/publishers/edit-publisher.tsx
+++ b/app/features/publishers/routes/publishers/edit-publisher.tsx
@@ -128,12 +128,7 @@ export default function EditPublisher({ loaderData }: Route.ComponentProps) {
       <Form id="edit-publisher-form" method="post" className="flex flex-col gap-6" onChange={markDirty}>
         <PublisherPersonalInformationForm user={user} onGenderChange={setGender} />
         <PublisherNominationForm user={user} gender={gender} />
-        <PublisherFieldServiceForm
-          user={user}
-          groups={groups}
-          hideAuxiliaryPioneer={hideAuxiliaryPioneer}
-          hideTypeSelect
-        />
+        <PublisherFieldServiceForm user={user} groups={groups} />
       </Form>
 
       {/* Pioneer appointments — separate forms, each posting its own enrolment intent (saved on their
@@ -182,7 +177,6 @@ export async function action({ request, params, context }: Route.ActionArgs) {
     isServant,
     isAnointed,
     group,
-    type,
     phone,
     address,
   } = submission.value
@@ -205,7 +199,6 @@ export async function action({ request, params, context }: Route.ActionArgs) {
         isAnointed,
         groupId: group ?? null,
         email: email ?? '',
-        type,
         address,
         phone,
       },
diff --git a/app/features/publishers/routes/publishers/new-publisher.tsx b/app/features/publishers/routes/publishers/new-publisher.tsx
index 0d230ea9..1bafa971 100644
--- a/app/features/publishers/routes/publishers/new-publisher.tsx
+++ b/app/features/publishers/routes/publishers/new-publisher.tsx
@@ -14,8 +14,6 @@ import {
   permissionsContext,
   withScopeFromContext,
 } from '~/shared/auth/route-context.server'
-import { getBoolSetting } from '~/shared/domain/settings.server'
-import { CongregationSettingKey } from '~/shared/types/congregation-setting-key'
 import { Permission } from '~/shared/types/permission'
 import { FormActions } from '~/shared/ui/FormActions'
 import { useUnsavedChanges } from '~/shared/ui/hooks/use-unsaved-changes'
@@ -41,18 +39,13 @@ export function loader({ context }: Route.LoaderArgs) {
 
   return withScopeFromContext(context, async db => {
     const groups = await db.publisherGroup.findMany({ where: { congregationId: currentUser.congregationId } })
-    const showAuxiliaryPioneer = await getBoolSetting(
-      db,
-      CongregationSettingKey.PermanentAuxiliaryPioneerProfileActivated,
-      currentUser.congregationId,
-    )
 
-    return { groups, hideAuxiliaryPioneer: !showAuxiliaryPioneer }
+    return { groups }
   })
 }
 
 export default function NewPublisher({ loaderData }: Route.ComponentProps) {
-  const { groups, hideAuxiliaryPioneer } = loaderData
+  const { groups } = loaderData
   const { blocker, markDirty } = useUnsavedChanges()
   const [gender, setGender] = useState<'male' | 'female' | null>(null)
 
@@ -69,7 +62,7 @@ export default function NewPublisher({ loaderData }: Route.ComponentProps) {
       <Form method="post" className="flex flex-col gap-6" onChange={markDirty}>
         <PublisherPersonalInformationForm onGenderChange={setGender} />
         <PublisherNominationForm gender={gender} />
-        <PublisherFieldServiceForm groups={groups} hideAuxiliaryPioneer={hideAuxiliaryPioneer} />
+        <PublisherFieldServiceForm groups={groups} />
 
         <FormActions>
           <SubmitButton size="lg">{m.publishers_new_submit()}</SubmitButton>
@@ -99,7 +92,6 @@ export async function action({ request, context }: Route.ActionArgs) {
     isServant,
     isAnointed,
     group,
-    type,
     phone,
     address,
   } = submission.value
@@ -118,7 +110,6 @@ export async function action({ request, context }: Route.ActionArgs) {
         isServant,
         isAnointed,
         groupId: group ?? null,
-        type,
         congregationId: currentUser.congregationId,
         phone: phone ?? '',
         address: address ?? '',
diff --git a/app/features/publishers/schemas/edit-publisher.schema.ts b/app/features/publishers/schemas/edit-publisher.schema.ts
index a29a43c8..0b35b736 100644
--- a/app/features/publishers/schemas/edit-publisher.schema.ts
+++ b/app/features/publishers/schemas/edit-publisher.schema.ts
@@ -1,5 +1,4 @@
 import { z } from 'zod'
-import { PublisherType } from '~/shared/types/publisher-type'
 import { nameSchema } from '~/shared/utils/name'
 import { phoneSchema } from '~/shared/utils/phone'
 
@@ -23,7 +22,6 @@ export const updatePublisherSchema = z.object({
     .optional()
     .transform(v => v === 'on'),
   group: z.coerce.number().optional(),
-  type: z.nativeEnum(PublisherType),
   phone: phoneSchema,
   address: z.string().optional().default(''),
 })
diff --git a/app/features/publishers/schemas/publisher.schema.test.ts b/app/features/publishers/schemas/publisher.schema.test.ts
index 28306251..5dbba1eb 100644
--- a/app/features/publishers/schemas/publisher.schema.test.ts
+++ b/app/features/publishers/schemas/publisher.schema.test.ts
@@ -6,9 +6,26 @@ const baseInput = {
   firstname: 'Jean',
   lastname: 'Dupont',
   gender: 'male' as const,
-  type: 'Normal',
 }
 
+// The pioneer type is not a member field any more — it is an enrolment, appointed from the pioneer
+// section of the edit page. Both forms must parse without one, and must not smuggle one back in.
+describe.each([
+  ['createPublisherSchema', createPublisherSchema],
+  ['updatePublisherSchema', updatePublisherSchema],
+])('%s — no pioneer type', (_name, schema) => {
+  it('parses without a type field', () => {
+    const result = schema.safeParse(baseInput)
+    expect(result.success).toBe(true)
+  })
+
+  it('does not carry a type through to the parsed value', () => {
+    const result = schema.safeParse({ ...baseInput, type: 'pionnier-permanant' })
+    expect(result.success).toBe(true)
+    if (result.success) expect(result.data).not.toHaveProperty('type')
+  })
+})
+
 describe.each([
   ['createPublisherSchema', createPublisherSchema],
   ['updatePublisherSchema', updatePublisherSchema],
diff --git a/app/features/publishers/schemas/publisher.schema.ts b/app/features/publishers/schemas/publisher.schema.ts
index e0d879ad..fe4ec120 100644
--- a/app/features/publishers/schemas/publisher.schema.ts
+++ b/app/features/publishers/schemas/publisher.schema.ts
@@ -1,5 +1,4 @@
 import { z } from 'zod'
-import { PublisherType } from '~/shared/types/publisher-type'
 import { nameSchema } from '~/shared/utils/name'
 import { phoneSchema } from '~/shared/utils/phone'
 
@@ -23,7 +22,6 @@ export const createPublisherSchema = z.object({
     .optional()
     .transform(v => v === 'on'),
   group: z.preprocess(v => (v === '' || v === undefined ? undefined : v), z.coerce.number().optional()),
-  type: z.nativeEnum(PublisherType),
   phone: phoneSchema,
   address: z.string().optional().default(''),
 })
diff --git a/app/features/publishers/server/member-identity.test.ts b/app/features/publishers/server/member-identity.test.ts
index 41ebf2ef..c7723657 100644
--- a/app/features/publishers/server/member-identity.test.ts
+++ b/app/features/publishers/server/member-identity.test.ts
@@ -1,10 +1,8 @@
 import { describe, expect, it } from 'vitest'
-import { PublisherType } from '~/shared/types/publisher-type'
 import { haveIdentityFlagsChanged, type MemberIdentityFlags } from './member-identity'
 
 const BASE: MemberIdentityFlags = {
   isPublisher: true,
-  type: PublisherType.Normal,
   isMale: true,
   baptismDate: new Date('2000-01-15'),
   isAnointed: false,
@@ -22,10 +20,6 @@ describe('haveIdentityFlagsChanged', () => {
     expect(haveIdentityFlagsChanged(BASE, { ...BASE, isPublisher: false })).toBe(true)
   })
 
-  it('detects type change', () => {
-    expect(haveIdentityFlagsChanged(BASE, { ...BASE, type: PublisherType.PionnierAuxiliaires })).toBe(true)
-  })
-
   it('detects isMale flip', () => {
     expect(haveIdentityFlagsChanged(BASE, { ...BASE, isMale: false })).toBe(true)
   })
diff --git a/app/features/publishers/server/member-identity.ts b/app/features/publishers/server/member-identity.ts
index 9c5c91a0..4e0220aa 100644
--- a/app/features/publishers/server/member-identity.ts
+++ b/app/features/publishers/server/member-identity.ts
@@ -1,11 +1,9 @@
-import type { PublisherType } from '~/shared/types/publisher-type'
 import { stripDiacritics } from '~/shared/utils/strip-diacritics'
 
 // The 8 fields whose value drives built-in-role assignment. Any mutation
 // that touches one must re-run syncBuiltInRoleAssignments.
 export type MemberIdentityFlags = {
   isPublisher: boolean
-  type: PublisherType
   isMale: boolean | null
   baptismDate: Date | null
   isAnointed: boolean
@@ -24,7 +22,6 @@ export type CreateDirectParams = {
   birthDate: Date | null
   baptismDate: Date | null
   isPublisher: boolean
-  type: PublisherType
   isHelder: boolean
   isServant: boolean
   isAnointed: boolean
@@ -35,7 +32,6 @@ export type CreateDirectParams = {
 
 export const MEMBER_IDENTITY_SELECT = {
   isPublisher: true,
-  type: true,
   isMale: true,
   baptismDate: true,
   isAnointed: true,
@@ -47,7 +43,6 @@ export const MEMBER_IDENTITY_SELECT = {
 export function haveIdentityFlagsChanged(before: MemberIdentityFlags, after: MemberIdentityFlags): boolean {
   return (
     before.isPublisher !== after.isPublisher ||
-    before.type !== after.type ||
     before.isMale !== after.isMale ||
     (before.baptismDate?.getTime() ?? null) !== (after.baptismDate?.getTime() ?? null) ||
     before.isAnointed !== after.isAnointed ||
@@ -67,7 +62,6 @@ export type MemberFormFields = {
   isServant: boolean
   isAnointed: boolean
   groupId: number | null
-  type: PublisherType
   phone: string
   address: string
   email: string
@@ -86,7 +80,6 @@ export function memberDataFromForm(params: MemberFormFields) {
     isServant: params.isServant,
     isAnointed: params.isAnointed,
     publisherGroupId: Number.isNaN(params.groupId) ? null : params.groupId,
-    type: params.type,
     address: params.address,
     phone: params.phone,
     email: params.email,
diff --git a/app/features/publishers/server/member-preconditions.server.integration.test.ts b/app/features/publishers/server/member-preconditions.server.integration.test.ts
index 99ab6e3b..c215a8ac 100644
--- a/app/features/publishers/server/member-preconditions.server.integration.test.ts
+++ b/app/features/publishers/server/member-preconditions.server.integration.test.ts
@@ -2,7 +2,6 @@ import { PrismaPg } from '@prisma/adapter-pg'
 import { afterAll, beforeAll, describe, expect, it } from 'vitest'
 import { PrismaClient } from '~/database/generated/client'
 import { ConflictError, NotFoundError } from '~/shared/errors/app-error.server'
-import { PublisherType } from '~/shared/types/publisher-type'
 import { _ensureMemberIsNotGroupResponsible, _loadMemberIdentity } from './member-preconditions.server'
 
 const adapter = new PrismaPg({
@@ -36,7 +35,6 @@ beforeAll(async () => {
         firstname: 'Pre',
         lastname: 'Cond',
         isPublisher: true,
-        type: PublisherType.Normal,
         congregationId: congId,
       },
     }),
@@ -57,7 +55,6 @@ describe('_loadMemberIdentity', () => {
   it('returns the identity flags for an existing member', async () => {
     const flags = await withScope(congId, tx => _loadMemberIdentity(tx, memberId, congId))
     expect(flags.isPublisher).toBe(true)
-    expect(flags.type).toBe(PublisherType.Normal)
   })
 
   it('throws NotFoundError for a missing member', async () => {
@@ -79,7 +76,6 @@ describe('_ensureMemberIsNotGroupResponsible', () => {
           firstname: 'Resp',
           lastname: 'Person',
           isPublisher: true,
-          type: PublisherType.Normal,
           congregationId: congId,
         },
       }),
diff --git a/app/features/publishers/server/member.aggregate.integration.test.ts b/app/features/publishers/server/member.aggregate.integration.test.ts
index f43e7eed..a11e3deb 100644
--- a/app/features/publishers/server/member.aggregate.integration.test.ts
+++ b/app/features/publishers/server/member.aggregate.integration.test.ts
@@ -96,6 +96,10 @@ const baseFormParams = {
   address: '',
 }
 
+// setPioneerType and bulkUpdateType are gone with the Member.type column. What bulkUpdateType did
+// for the permanent-auxiliary setting now lives in endOngoingEnrolmentsOfType, covered in
+// pioneer-enrolment.workflow.integration.test.ts; setPioneerType has no successor because nothing
+// caches the status any more.
 describe('member.aggregate — integration', () => {
   it('createMember persists the row and audits PublisherCreated', async () => {
     auditMock.mockClear()
@@ -300,70 +304,4 @@ describe('member.aggregate — integration', () => {
 
     await testDb.publisherGroup.delete({ where: { id: group.id } })
   })
-
-  it('setPioneerType writes the cached column but no longer grants the pioneer role on its own', async () => {
-    const member = await withScope(congId, tx =>
-      memberAggregate.createMember(tx, congregationInfo as never, {
-        ...baseFormParams,
-        firstname: `SetType-${ts}`,
-        type: PublisherType.Normal,
-        congregationId: congId,
-        actorId: 1,
-      }),
-    )
-    const pioneerRole = await testDb.role.findFirstOrThrow({ where: { key: 'pioneer', congregationId: congId } })
-    const before = await testDb.memberRoleAssignment.findFirst({
-      where: { memberId: member.id, roleId: pioneerRole.id },
-    })
-    expect(before).toBeNull()
-
-    auditMock.mockClear()
-    await withScope(congId, tx =>
-      memberAggregate.setPioneerType(tx, member.id, congId, 1, PublisherType.PionnierPermanant),
-    )
-
-    const after = await testDb.member.findUniqueOrThrow({ where: { id: member.id } })
-    expect(after.type).toBe(PublisherType.PionnierPermanant)
-    // The pioneer role is derived from the member's stints now, not from this column, so writing
-    // the column alone grants nothing — this member has no enrolment. Not a weakened assertion: the
-    // role attaching off a real enrolment is covered in pioneer-enrolment.workflow.integration.test,
-    // and setPioneerType is only ever reached through that workflow's recompute.
-    const assignment = await testDb.memberRoleAssignment.findFirst({
-      where: { memberId: member.id, roleId: pioneerRole.id },
-    })
-    expect(assignment).toBeNull()
-    expect(auditMock).toHaveBeenCalledWith(
-      expect.objectContaining({ action: 'publisher.updated', entityId: member.id }),
-    )
-  })
-
-  it('bulkUpdateType flips all matching members and re-syncs each', async () => {
-    const m1 = await withScope(congId, tx =>
-      memberAggregate.createMember(tx, congregationInfo as never, {
-        ...baseFormParams,
-        firstname: `Bulk1-${ts}`,
-        type: PublisherType.PionnierAuxiliaires,
-        congregationId: congId,
-        actorId: 1,
-      }),
-    )
-    const m2 = await withScope(congId, tx =>
-      memberAggregate.createMember(tx, congregationInfo as never, {
-        ...baseFormParams,
-        firstname: `Bulk2-${ts}`,
-        type: PublisherType.PionnierAuxiliaires,
-        congregationId: congId,
-        actorId: 1,
-      }),
-    )
-
-    await withScope(congId, tx =>
-      memberAggregate.bulkUpdateType(tx, congId, 1, PublisherType.PionnierAuxiliaires, PublisherType.Normal),
-    )
-
-    const after1 = await testDb.member.findUniqueOrThrow({ where: { id: m1.id } })
-    const after2 = await testDb.member.findUniqueOrThrow({ where: { id: m2.id } })
-    expect(after1.type).toBe(PublisherType.Normal)
-    expect(after2.type).toBe(PublisherType.Normal)
-  })
 })
diff --git a/app/features/publishers/server/member.aggregate.ts b/app/features/publishers/server/member.aggregate.ts
index f25211c7..ebdd7d7e 100644
--- a/app/features/publishers/server/member.aggregate.ts
+++ b/app/features/publishers/server/member.aggregate.ts
@@ -5,7 +5,6 @@ import { LimitService } from '~/shared/domain/limits.server'
 import { NotFoundError } from '~/shared/errors/app-error.server'
 import type { TransactionClient } from '~/shared/infra/db.server'
 import type { MemberId } from '~/shared/types/branded'
-import type { PublisherType } from '~/shared/types/publisher-type'
 import { stripDiacritics } from '~/shared/utils/strip-diacritics'
 import { purgeEmergencyContacts } from './emergency-info.aggregate'
 import {
@@ -272,54 +271,3 @@ export async function anonymize(
   })
   audit({ action: AuditAction.UserAnonymized, congregationId, actorId, entityType: 'Member', entityId: memberId })
 }
-
-export async function bulkUpdateType(
-  db: TransactionClient,
-  congregationId: number,
-  actorId: number,
-  from: PublisherType,
-  to: PublisherType,
-): Promise<void> {
-  // aggregate-boundaries-allow: precondition read — capture affected ids so we can re-sync each after the bulk update
-  const affected = await db.member.findMany({
-    where: { congregationId, type: from },
-    select: { id: true },
-  })
-
-  await db.member.updateMany({ where: { congregationId, type: from }, data: { type: to } })
-
-  for (const m of affected) {
-    await syncBuiltInRoleAssignments(db, m.id, congregationId, actorId)
-  }
-}
-
-// Sets a member's standing pioneer type (the synced `Member.type` cache that drives built-in
-// role sync). Called by the pioneer-enrolment workflow when an *ongoing* stint opens/closes —
-// single-month auxiliary enrolments deliberately do NOT touch `Member.type` (see the enrolment
-// workflow and CLAUDE.md). Kept in the aggregate because it writes `Member` + re-syncs roles.
-export async function setPioneerType(
-  db: TransactionClient,
-  memberId: number,
-  congregationId: number,
-  actorId: number,
-  type: PublisherType,
-) {
-  const member = await db.member.update({
-    // biome-ignore lint/style/useNamingConvention: Prisma compound-key naming
-    where: { id_congregationId: { id: memberId, congregationId } },
-    data: { type },
-  })
-
-  await syncBuiltInRoleAssignments(db, memberId, congregationId, actorId)
-
-  audit({
-    action: AuditAction.PublisherUpdated,
-    congregationId,
-    actorId,
-    entityType: 'Member',
-    entityId: memberId,
-    metadata: { type },
-  })
-
-  return member
-}
diff --git a/app/features/publishers/server/pioneer-activity.integration.test.ts b/app/features/publishers/server/pioneer-activity.integration.test.ts
index a56a73f6..da72a920 100644
--- a/app/features/publishers/server/pioneer-activity.integration.test.ts
+++ b/app/features/publishers/server/pioneer-activity.integration.test.ts
@@ -41,7 +41,6 @@ beforeAll(async () => {
         firstname: 'Reg',
         lastname: 'Pioneer',
         isPublisher: true,
-        type: PublisherType.PionnierPermanant,
         baptismDate: new Date('2015-01-01'),
         congregationId,
       },
diff --git a/app/features/publishers/server/pioneer-activity.queries.test.ts b/app/features/publishers/server/pioneer-activity.queries.test.ts
index f2dd1f37..b233ad05 100644
--- a/app/features/publishers/server/pioneer-activity.queries.test.ts
+++ b/app/features/publishers/server/pioneer-activity.queries.test.ts
@@ -35,7 +35,7 @@ function member(id: number, type: PublisherType, activities: ReturnType<typeof a
     type,
     publisherGroup,
     activities,
-    pioneerEnrolments: deriveStintsFromActivity(activities, type),
+    pioneerEnrolments: deriveStintsFromActivity(activities),
   }
 }
 
diff --git a/app/features/publishers/server/pioneer-activity.queries.ts b/app/features/publishers/server/pioneer-activity.queries.ts
index 0a5e9abb..6b206b1b 100644
--- a/app/features/publishers/server/pioneer-activity.queries.ts
+++ b/app/features/publishers/server/pioneer-activity.queries.ts
@@ -1,7 +1,7 @@
 import type { TransactionClient } from '~/shared/infra/db.server'
 import { PublisherType } from '~/shared/types/publisher-type'
 
-import type { EnrolmentPeriod } from '../model/pioneer-enrolment'
+import { type EnrolmentPeriod, standingTypeFromEnrolments } from '../model/pioneer-enrolment'
 import { type EnrolmentActualMonth, planFromEnrolments } from '../model/pioneer-enrolment-pace'
 import { computeAuxiliarySummary, computePioneerPace, type PioneerMonth, type PioneerPace } from '../model/pioneer-pace'
 import type {
@@ -86,9 +86,10 @@ export async function getPioneerActivitySummary(
       leftAt: null,
       inactiveAt: null,
       OR: [
-        { type: { not: PublisherType.Normal } },
-        { activities: { some: { ...serviceYearWhere(serviceYear), type: { not: PublisherType.Normal } } } },
+        // Anyone with a stint is a roster candidate; the enrolment IS the plan now. Reports still
+        // qualify a member because a pre-enrolment report can predate any stint we hold.
         { pioneerEnrolments: { some: {} } },
+        { activities: { some: { ...serviceYearWhere(serviceYear), type: { not: PublisherType.Normal } } } },
       ],
     },
     include: {
@@ -121,7 +122,12 @@ function classifyPioneerMember(
 ): PioneerActivity | null {
   const thisYear = member.activities.filter(r => serviceYearOfRow(r.month, r.year) === serviceYear)
   const rows: EnrolmentActualMonth[] = dedupeLatestPerMonth(thisYear)
-  const plan = planFromEnrolments(member.pioneerEnrolments, rows, serviceYear, member.type)
+  const plan = planFromEnrolments(
+    member.pioneerEnrolments,
+    rows,
+    serviceYear,
+    standingTypeFromEnrolments(member.pioneerEnrolments),
+  )
   if (plan === null) return null
 
   const typeRate = rates.get(plan.rosterType)
@@ -208,7 +214,6 @@ interface MemberWithActivities {
   id: number
   firstname: string
   lastname: string
-  type: PublisherType
   publisherGroup: { name: string } | null
   activities: ActivityRow[]
 }
diff --git a/app/features/publishers/server/pioneer-enrolment-backfill.server.integration.test.ts b/app/features/publishers/server/pioneer-enrolment-backfill.server.integration.test.ts
index dfe27af8..28ed9b79 100644
--- a/app/features/publishers/server/pioneer-enrolment-backfill.server.integration.test.ts
+++ b/app/features/publishers/server/pioneer-enrolment-backfill.server.integration.test.ts
@@ -36,7 +36,7 @@ beforeAll(async () => {
   congId = cong.id
   await withScope(congId, async tx => {
     const member = await tx.member.create({
-      data: { firstname: 'Back', lastname: 'Fill', isPublisher: true, type: NORMAL, congregationId: congId },
+      data: { firstname: 'Back', lastname: 'Fill', isPublisher: true, congregationId: congId },
     })
     memberId = member.id
     // Representative history: Permanent Sept–Oct 2025, a re-filed Oct (higher id wins, still Permanent),
@@ -77,9 +77,7 @@ afterAll(async () => {
 
 describe('backfillMemberEnrolments', () => {
   it('persists the derived stints through the aggregate', async () => {
-    const written = await withScope(congId, tx =>
-      backfillMemberEnrolments(tx, { id: memberId, type: NORMAL }, congId, 1),
-    )
+    const written = await withScope(congId, tx => backfillMemberEnrolments(tx, { id: memberId }, congId, 1))
     expect(written).toBe(2)
 
     const stints = await testDb.pioneerEnrolment.findMany({
@@ -94,9 +92,7 @@ describe('backfillMemberEnrolments', () => {
   })
 
   it('is idempotent — a re-run writes nothing', async () => {
-    const written = await withScope(congId, tx =>
-      backfillMemberEnrolments(tx, { id: memberId, type: NORMAL }, congId, 1),
-    )
+    const written = await withScope(congId, tx => backfillMemberEnrolments(tx, { id: memberId }, congId, 1))
     expect(written).toBe(0)
     expect(await testDb.pioneerEnrolment.count({ where: { memberId } })).toBe(2)
   })
@@ -106,7 +102,7 @@ describe('backfillMemberEnrolments — no pioneer history', () => {
   it('writes nothing for a member with only Normal activity', async () => {
     const plainId = await withScope(congId, async tx => {
       const plain = await tx.member.create({
-        data: { firstname: 'Plain', lastname: 'Publisher', isPublisher: true, type: NORMAL, congregationId: congId },
+        data: { firstname: 'Plain', lastname: 'Publisher', isPublisher: true, congregationId: congId },
       })
       await tx.publisherActivity.create({
         data: {
@@ -122,9 +118,7 @@ describe('backfillMemberEnrolments — no pioneer history', () => {
       return plain.id
     })
 
-    const written = await withScope(congId, tx =>
-      backfillMemberEnrolments(tx, { id: plainId, type: NORMAL }, congId, 1),
-    )
+    const written = await withScope(congId, tx => backfillMemberEnrolments(tx, { id: plainId }, congId, 1))
     expect(written).toBe(0)
     expect(await testDb.pioneerEnrolment.count({ where: { memberId: plainId } })).toBe(0)
   })
diff --git a/app/features/publishers/server/pioneer-enrolment-backfill.server.test.ts b/app/features/publishers/server/pioneer-enrolment-backfill.server.test.ts
index be944883..5bc691d4 100644
--- a/app/features/publishers/server/pioneer-enrolment-backfill.server.test.ts
+++ b/app/features/publishers/server/pioneer-enrolment-backfill.server.test.ts
@@ -16,14 +16,14 @@ describe('deriveStintsFromActivity', () => {
   it('groups a continuing annual pioneer (spanning the Sept boundary) into one ongoing stint', () => {
     // Jun 2025 (SY 2024) … Jan 2026 (SY 2025), member still permanent → ongoing, spans years.
     const rows = [row(1, 5, 2025, PERM), row(2, 8, 2025, PERM), row(3, 0, 2026, PERM)]
-    const stints = deriveStintsFromActivity(rows, PERM)
+    const stints = deriveStintsFromActivity(rows)
     expect(stints).toEqual([
       { type: PERM, startMonth: 5, startYear: 2025, endMonth: null, endYear: null, monthlyGoal: null },
     ])
   })
 
   it('leaves a mid-year annual start ongoing from its first reported month', () => {
-    const stints = deriveStintsFromActivity([row(1, 0, 2026, PERM), row(2, 1, 2026, PERM)], PERM)
+    const stints = deriveStintsFromActivity([row(1, 0, 2026, PERM), row(2, 1, 2026, PERM)])
     expect(stints).toEqual([
       { type: PERM, startMonth: 0, startYear: 2026, endMonth: null, endYear: null, monthlyGoal: null },
     ])
@@ -32,7 +32,7 @@ describe('deriveStintsFromActivity', () => {
   it('closes a concluded annual run at its last served month (member back to Normal)', () => {
     // Permanent Sept–Nov 2025, then Normal Dec → concluded, stint bounded at Nov.
     const rows = [row(1, 8, 2025, PERM), row(2, 9, 2025, PERM), row(3, 10, 2025, PERM), row(4, 11, 2025, NORMAL)]
-    const stints = deriveStintsFromActivity(rows, NORMAL)
+    const stints = deriveStintsFromActivity(rows)
     expect(stints).toEqual([
       { type: PERM, startMonth: 8, startYear: 2025, endMonth: 10, endYear: 2025, monthlyGoal: null },
     ])
@@ -40,7 +40,7 @@ describe('deriveStintsFromActivity', () => {
 
   it('does not break a run across a no-row gap', () => {
     // Sept, (no Oct), Nov — one continuous ongoing stint.
-    const stints = deriveStintsFromActivity([row(1, 8, 2025, PERM), row(2, 10, 2025, PERM)], PERM)
+    const stints = deriveStintsFromActivity([row(1, 8, 2025, PERM), row(2, 10, 2025, PERM)])
     expect(stints).toEqual([
       { type: PERM, startMonth: 8, startYear: 2025, endMonth: null, endYear: null, monthlyGoal: null },
     ])
@@ -48,24 +48,29 @@ describe('deriveStintsFromActivity', () => {
 
   it('emits one single-month stint per reported month for a MONTHLY auxiliary (member not permanent aux)', () => {
     // Member type Normal, isolated auxiliary months Oct + Dec (gap Nov) → two single-month stints.
-    const stints = deriveStintsFromActivity([row(1, 9, 2025, AUX), row(2, 11, 2025, AUX)], NORMAL)
+    const stints = deriveStintsFromActivity([row(1, 9, 2025, AUX), row(2, 11, 2025, AUX)])
     expect(stints).toEqual([
       { type: AUX, startMonth: 9, startYear: 2025, endMonth: 9, endYear: 2025, monthlyGoal: null },
       { type: AUX, startMonth: 11, startYear: 2025, endMonth: 11, endYear: 2025, monthlyGoal: null },
     ])
   })
 
-  it('groups a PERMANENT auxiliary (member.type auxiliaires) into one ongoing stint', () => {
-    const stints = deriveStintsFromActivity([row(1, 8, 2025, AUX), row(2, 9, 2025, AUX)], AUX)
+  // A permanent auxiliary is no longer recoverable from activity alone: the snapshots look
+  // identical to consecutive monthly sign-ups, and the column that distinguished them is gone.
+  // Contiguous auxiliary months therefore backfill as single-month stints, which grants no standing
+  // status — the safe direction for a guess.
+  it('backfills contiguous auxiliary months as single-month stints, not one ongoing stint', () => {
+    const stints = deriveStintsFromActivity([row(1, 8, 2025, AUX), row(2, 9, 2025, AUX)])
     expect(stints).toEqual([
-      { type: AUX, startMonth: 8, startYear: 2025, endMonth: null, endYear: null, monthlyGoal: null },
+      { type: AUX, startMonth: 8, startYear: 2025, endMonth: 8, endYear: 2025, monthlyGoal: null },
+      { type: AUX, startMonth: 9, startYear: 2025, endMonth: 9, endYear: 2025, monthlyGoal: null },
     ])
   })
 
   it('handles a mid-year type switch: bounded annual stint + monthly auxiliary single-month', () => {
     // Permanent Sept–Oct, then Auxiliary Nov; member type Normal (monthly aux).
     const rows = [row(1, 8, 2025, PERM), row(2, 9, 2025, PERM), row(3, 10, 2025, AUX)]
-    const stints = deriveStintsFromActivity(rows, NORMAL)
+    const stints = deriveStintsFromActivity(rows)
     expect(stints).toEqual([
       { type: PERM, startMonth: 8, startYear: 2025, endMonth: 9, endYear: 2025, monthlyGoal: null },
       { type: AUX, startMonth: 10, startYear: 2025, endMonth: 10, endYear: 2025, monthlyGoal: null },
@@ -75,14 +80,14 @@ describe('deriveStintsFromActivity', () => {
   it('resolves a re-filed month to its latest type before grouping', () => {
     // Oct filed as Normal (id 2) then re-filed as Permanent (id 3, wins). Sept + Oct → one run.
     const rows = [row(1, 8, 2025, PERM), row(2, 9, 2025, NORMAL), row(3, 9, 2025, PERM)]
-    const stints = deriveStintsFromActivity(rows, PERM)
+    const stints = deriveStintsFromActivity(rows)
     expect(stints).toEqual([
       { type: PERM, startMonth: 8, startYear: 2025, endMonth: null, endYear: null, monthlyGoal: null },
     ])
   })
 
   it('returns no stints when the member never had pioneer activity', () => {
-    expect(deriveStintsFromActivity([row(1, 8, 2025, NORMAL)], NORMAL)).toEqual([])
-    expect(deriveStintsFromActivity([], NORMAL)).toEqual([])
+    expect(deriveStintsFromActivity([row(1, 8, 2025, NORMAL)])).toEqual([])
+    expect(deriveStintsFromActivity([])).toEqual([])
   })
 })
diff --git a/app/features/publishers/server/pioneer-enrolment-backfill.server.ts b/app/features/publishers/server/pioneer-enrolment-backfill.server.ts
index fa3c1498..ac17b461 100644
--- a/app/features/publishers/server/pioneer-enrolment-backfill.server.ts
+++ b/app/features/publishers/server/pioneer-enrolment-backfill.server.ts
@@ -79,7 +79,7 @@ function singleMonthStint(r: ActivityTypeRow): StintDraft {
 // Pure derivation (spec §6.1). `memberType` is the member's standing type — it distinguishes a
 // permanent auxiliary (grouped like an annual stint) from a monthly auxiliary (one single-month
 // stint per reported month).
-export function deriveStintsFromActivity(rows: ActivityTypeRow[], memberType: PublisherType): StintDraft[] {
+export function deriveStintsFromActivity(rows: ActivityTypeRow[]): StintDraft[] {
   const deduped = dedupeLatestPerMonth(rows)
 
   // Concluded here decides whether the member's FINAL run gets a close date: true when their latest
@@ -87,10 +87,8 @@ export function deriveStintsFromActivity(rows: ActivityTypeRow[], memberType: Pu
   // pace query's per-service-year "concluded" (pioneer-enrolment-pace.ts), which asks whether the
   // member is finished pioneering *this year*. The parity test (§14) checks the two produce matching
   // pace, not that the intermediate `concluded` values are identical.
-  const standingType = deduped.at(-1)?.type ?? memberType
+  const standingType = deduped.at(-1)?.type ?? PublisherType.Normal
   const concluded = !isPioneerType(standingType)
-  const isPermanentAux = memberType === PublisherType.PionnierAuxiliaires
-
   const runs = groupRuns(deduped)
   const lastRunIndex = runs.length - 1
 
@@ -98,8 +96,12 @@ export function deriveStintsFromActivity(rows: ActivityTypeRow[], memberType: Pu
   runs.forEach((run, index) => {
     if (!isPioneerType(run.type)) return // a Normal run is a gap, not a stint
 
-    if (isAuxiliaryType(run.type) && !isPermanentAux) {
-      // Monthly auxiliary: never grouped — one single-month stint per reported month.
+    if (isAuxiliaryType(run.type)) {
+      // Every auxiliary run becomes single-month stints. Activity snapshots cannot tell a MONTHLY
+      // auxiliary from a PERMANENT one — that distinction used to come from the `Member.type`
+      // column, which no longer exists — and monthly is both the common case and the safe guess:
+      // a single-month stint grants no standing status, so a wrong guess never hands someone a
+      // pioneer role they should not have. A genuine permanent auxiliary is re-appointed by hand.
       for (const r of run.rows) stints.push(singleMonthStint(r))
       return
     }
@@ -115,7 +117,6 @@ export function deriveStintsFromActivity(rows: ActivityTypeRow[], memberType: Pu
 
 interface BackfillMember {
   id: number
-  type: PublisherType
 }
 
 // Persist one member's derived stints via the aggregate. Idempotent: a member who already has any
@@ -134,7 +135,7 @@ export async function backfillMemberEnrolments(
     select: { id: true, month: true, year: true, type: true },
   })
 
-  const stints = deriveStintsFromActivity(activity, member.type)
+  const stints = deriveStintsFromActivity(activity)
   for (const stint of stints) {
     await openEnrolment(db, member.id, congregationId, actorId, {
       type: stint.type,
@@ -154,7 +155,7 @@ export async function backfillCongregationEnrolments(
 ): Promise<{ members: number; stints: number }> {
   const members = await db.member.findMany({
     where: { congregationId },
-    select: { id: true, type: true },
+    select: { id: true },
   })
   let stints = 0
   for (const member of members) {
diff --git a/app/features/publishers/server/pioneer-enrolment.aggregate.integration.test.ts b/app/features/publishers/server/pioneer-enrolment.aggregate.integration.test.ts
index 5b41b34f..917ccbf2 100644
--- a/app/features/publishers/server/pioneer-enrolment.aggregate.integration.test.ts
+++ b/app/features/publishers/server/pioneer-enrolment.aggregate.integration.test.ts
@@ -44,7 +44,6 @@ beforeAll(async () => {
         firstname: 'Enrol',
         lastname: 'Pioneer',
         isPublisher: true,
-        type: PublisherType.PionnierPermanant,
         baptismDate: new Date('2015-01-01'),
         congregationId,
       },
@@ -116,7 +115,7 @@ describe('pioneer-enrolment aggregate (integration)', () => {
   async function freshMember(name: string): Promise<number> {
     const m = await withScope(congregationId, tx =>
       tx.member.create({
-        data: { firstname: name, lastname: 'Agg', isPublisher: true, type: PublisherType.Normal, congregationId },
+        data: { firstname: name, lastname: 'Agg', isPublisher: true, congregationId },
       }),
     )
     return m.id
diff --git a/app/features/publishers/server/pioneer-enrolment.queries.integration.test.ts b/app/features/publishers/server/pioneer-enrolment.queries.integration.test.ts
index 039c88ae..a2e25674 100644
--- a/app/features/publishers/server/pioneer-enrolment.queries.integration.test.ts
+++ b/app/features/publishers/server/pioneer-enrolment.queries.integration.test.ts
@@ -35,7 +35,7 @@ beforeAll(async () => {
   congId = cong.id
   await withScope(congId, async tx => {
     const member = await tx.member.create({
-      data: { firstname: 'Q', lastname: 'Uery', isPublisher: true, type: PublisherType.Normal, congregationId: congId },
+      data: { firstname: 'Q', lastname: 'Uery', isPublisher: true, congregationId: congId },
     })
     memberId = member.id
     // Two stints for this member: an annual one inside SY 2025, and one entirely in a prior SY.
diff --git a/app/features/publishers/server/pioneer-enrolment.workflow.integration.test.ts b/app/features/publishers/server/pioneer-enrolment.workflow.integration.test.ts
index 2f427d15..522cd5d8 100644
--- a/app/features/publishers/server/pioneer-enrolment.workflow.integration.test.ts
+++ b/app/features/publishers/server/pioneer-enrolment.workflow.integration.test.ts
@@ -3,7 +3,9 @@ import { afterAll, beforeAll, describe, expect, it } from 'vitest'
 import { PrismaClient } from '~/database/generated/client'
 import { flushPendingAuditWrites } from '~/shared/domain/audit.server'
 import { PublisherType } from '~/shared/types/publisher-type'
+import { standingTypeFromEnrolments } from '../model/pioneer-enrolment'
 import {
+  endOngoingEnrolmentsOfType,
   endPioneerEnrolment,
   enrolPioneer,
   removePioneerEnrolment,
@@ -58,7 +60,6 @@ async function makePublisher(name: string): Promise<number> {
         firstname: name,
         lastname: 'Test',
         isPublisher: true,
-        type: PublisherType.Normal,
         baptismDate: new Date('2010-01-01'),
         congregationId: congId,
       },
@@ -74,14 +75,19 @@ async function pioneerRoleAttached(memberId: number): Promise<boolean> {
   return assignment !== null
 }
 
+// The member's standing status now lives only in their stints — read it the way production does.
+async function standingTypeOf(memberId: number): Promise<PublisherType> {
+  const stints = await testDb.pioneerEnrolment.findMany({ where: { memberId } })
+  return standingTypeFromEnrolments(stints)
+}
+
 describe('pioneer-enrolment workflow (integration)', () => {
   it('an ongoing ANNUAL enrol sets Member.type and attaches the pioneer role', async () => {
     const memberId = await makePublisher(`Annual-${ts}`)
     await withScope(congId, tx =>
       enrolPioneer(tx, memberId, congId, 1, { type: PublisherType.PionnierPermanant, startMonth: 8, startYear: 2025 }),
     )
-    const after = await testDb.member.findUniqueOrThrow({ where: { id: memberId } })
-    expect(after.type).toBe(PublisherType.PionnierPermanant)
+    expect(await standingTypeOf(memberId)).toBe(PublisherType.PionnierPermanant)
     expect(await pioneerRoleAttached(memberId)).toBe(true)
   })
 
@@ -94,8 +100,7 @@ describe('pioneer-enrolment workflow (integration)', () => {
         startYear: 2025,
       }),
     )
-    const after = await testDb.member.findUniqueOrThrow({ where: { id: memberId } })
-    expect(after.type).toBe(PublisherType.PionnierAuxiliaires)
+    expect(await standingTypeOf(memberId)).toBe(PublisherType.PionnierAuxiliaires)
     expect(await pioneerRoleAttached(memberId)).toBe(true)
   })
 
@@ -111,8 +116,7 @@ describe('pioneer-enrolment workflow (integration)', () => {
         monthlyGoal: 15,
       }),
     )
-    const after = await testDb.member.findUniqueOrThrow({ where: { id: memberId } })
-    expect(after.type).toBe(PublisherType.Normal)
+    expect(await standingTypeOf(memberId)).toBe(PublisherType.Normal)
     expect(await pioneerRoleAttached(memberId)).toBe(false)
     // The enrolment record still exists (status is read from it, not from Member.type).
     const enrolments = await testDb.pioneerEnrolment.findMany({ where: { memberId } })
@@ -125,14 +129,11 @@ describe('pioneer-enrolment workflow (integration)', () => {
     const enrolment = await withScope(congId, tx =>
       enrolPioneer(tx, memberId, congId, 1, { type: PublisherType.PionnierPermanant, startMonth: 8, startYear: 2025 }),
     )
-    expect((await testDb.member.findUniqueOrThrow({ where: { id: memberId } })).type).toBe(
-      PublisherType.PionnierPermanant,
-    )
+    expect(await standingTypeOf(memberId)).toBe(PublisherType.PionnierPermanant)
 
     await withScope(congId, tx => endPioneerEnrolment(tx, enrolment.id, congId, 1, { endMonth: 1, endYear: 2026 }))
 
-    const after = await testDb.member.findUniqueOrThrow({ where: { id: memberId } })
-    expect(after.type).toBe(PublisherType.Normal)
+    expect(await standingTypeOf(memberId)).toBe(PublisherType.Normal)
     expect(await pioneerRoleAttached(memberId)).toBe(false)
   })
 
@@ -152,7 +153,7 @@ describe('pioneer-enrolment workflow (integration)', () => {
     await withScope(congId, tx => removePioneerEnrolment(tx, enrolment.id, congId, 1))
 
     expect(await testDb.pioneerEnrolment.count({ where: { id: enrolment.id } })).toBe(0)
-    expect((await testDb.member.findUniqueOrThrow({ where: { id: memberId } })).type).toBe(PublisherType.Normal)
+    expect(await standingTypeOf(memberId)).toBe(PublisherType.Normal)
   })
 
   it('removing the last ongoing stint reverts Member.type to Normal', async () => {
@@ -160,14 +161,11 @@ describe('pioneer-enrolment workflow (integration)', () => {
     const enrolment = await withScope(congId, tx =>
       enrolPioneer(tx, memberId, congId, 1, { type: PublisherType.PionnierPermanant, startMonth: 8, startYear: 2025 }),
     )
-    expect((await testDb.member.findUniqueOrThrow({ where: { id: memberId } })).type).toBe(
-      PublisherType.PionnierPermanant,
-    )
+    expect(await standingTypeOf(memberId)).toBe(PublisherType.PionnierPermanant)
 
     await withScope(congId, tx => removePioneerEnrolment(tx, enrolment.id, congId, 1))
 
-    const after = await testDb.member.findUniqueOrThrow({ where: { id: memberId } })
-    expect(after.type).toBe(PublisherType.Normal)
+    expect(await standingTypeOf(memberId)).toBe(PublisherType.Normal)
     expect(await pioneerRoleAttached(memberId)).toBe(false)
   })
 
@@ -193,8 +191,7 @@ describe('pioneer-enrolment workflow (integration)', () => {
       }),
     )
 
-    const member = await testDb.member.findUniqueOrThrow({ where: { id: memberId } })
-    expect(member.type).toBe(PublisherType.Normal)
+    expect(await standingTypeOf(memberId)).toBe(PublisherType.Normal)
     expect(await pioneerRoleAttached(memberId)).toBe(false)
   })
 
@@ -215,8 +212,7 @@ describe('pioneer-enrolment workflow (integration)', () => {
       updatePioneerEnrolment(tx, enrolment.id, congId, 1, { startMonth: 8, startYear: 2025 }),
     )
 
-    const member = await testDb.member.findUniqueOrThrow({ where: { id: memberId } })
-    expect(member.type).toBe(PublisherType.PionnierSpecial)
+    expect(await standingTypeOf(memberId)).toBe(PublisherType.PionnierSpecial)
     expect(await pioneerRoleAttached(memberId)).toBe(true)
   })
 
@@ -238,7 +234,73 @@ describe('pioneer-enrolment workflow (integration)', () => {
       }),
     )
 
-    const member = await testDb.member.findUniqueOrThrow({ where: { id: memberId } })
-    expect(member.type).toBe(PublisherType.Missionnaire)
+    expect(await standingTypeOf(memberId)).toBe(PublisherType.Missionnaire)
+  })
+
+  // Replaces the old bulkUpdateType: turning off the permanent-auxiliary profile used to flip the
+  // cached column, which left the ongoing stints open and contradicting it. Closing the stints is
+  // the same intent expressed against the source of truth.
+  it('endOngoingEnrolmentsOfType closes ongoing stints of that type and drops the role', async () => {
+    const memberId = await makePublisher(`BulkAux-${ts}`)
+    await withScope(congId, tx =>
+      enrolPioneer(tx, memberId, congId, 1, {
+        type: PublisherType.PionnierAuxiliaires,
+        startMonth: 8,
+        startYear: 2025,
+      }),
+    )
+    expect(await pioneerRoleAttached(memberId)).toBe(true)
+
+    await withScope(congId, tx =>
+      endOngoingEnrolmentsOfType(tx, congId, 1, PublisherType.PionnierAuxiliaires, { endMonth: 10, endYear: 2025 }),
+    )
+
+    const stints = await testDb.pioneerEnrolment.findMany({ where: { memberId, congregationId: congId } })
+    expect(stints).toHaveLength(1)
+    expect(stints[0].endMonth).toBe(10)
+    expect(stints[0].endYear).toBe(2025)
+    expect(await pioneerRoleAttached(memberId)).toBe(false)
+  })
+
+  it('endOngoingEnrolmentsOfType leaves other pioneer types alone', async () => {
+    const memberId = await makePublisher(`BulkPerm-${ts}`)
+    await withScope(congId, tx =>
+      enrolPioneer(tx, memberId, congId, 1, {
+        type: PublisherType.PionnierPermanant,
+        startMonth: 8,
+        startYear: 2025,
+      }),
+    )
+
+    await withScope(congId, tx =>
+      endOngoingEnrolmentsOfType(tx, congId, 1, PublisherType.PionnierAuxiliaires, { endMonth: 10, endYear: 2025 }),
+    )
+
+    const stints = await testDb.pioneerEnrolment.findMany({ where: { memberId, congregationId: congId } })
+    expect(stints[0].endMonth).toBeNull()
+    expect(await pioneerRoleAttached(memberId)).toBe(true)
+  })
+
+  // A single-month auxiliary is already closed, so it is not "ongoing" and must not be re-dated.
+  it('endOngoingEnrolmentsOfType does not touch an already-closed single-month auxiliary', async () => {
+    const memberId = await makePublisher(`BulkMonthly-${ts}`)
+    await withScope(congId, tx =>
+      enrolPioneer(tx, memberId, congId, 1, {
+        type: PublisherType.PionnierAuxiliaires,
+        startMonth: 3,
+        startYear: 2026,
+        endMonth: 3,
+        endYear: 2026,
+        monthlyGoal: 30,
+      }),
+    )
+
+    await withScope(congId, tx =>
+      endOngoingEnrolmentsOfType(tx, congId, 1, PublisherType.PionnierAuxiliaires, { endMonth: 10, endYear: 2025 }),
+    )
+
+    const stints = await testDb.pioneerEnrolment.findMany({ where: { memberId, congregationId: congId } })
+    expect(stints[0].endMonth).toBe(3)
+    expect(stints[0].endYear).toBe(2026)
   })
 })
diff --git a/app/features/publishers/server/pioneer-enrolment.workflow.ts b/app/features/publishers/server/pioneer-enrolment.workflow.ts
index cf12ac9a..8bd70c25 100644
--- a/app/features/publishers/server/pioneer-enrolment.workflow.ts
+++ b/app/features/publishers/server/pioneer-enrolment.workflow.ts
@@ -1,7 +1,7 @@
 import type { PioneerEnrolment } from '~/database/generated/client'
+import { syncBuiltInRoleAssignments } from '~/shared/domain/built-in-roles.server'
 import type { TransactionClient } from '~/shared/infra/db.server'
-import { standingTypeFromEnrolments } from '../model/pioneer-enrolment'
-import { setPioneerType } from './member.aggregate'
+import type { PublisherType } from '~/shared/types/publisher-type'
 import {
   closeEnrolment,
   deleteEnrolment,
@@ -11,28 +11,23 @@ import {
   updateEnrolment,
 } from './pioneer-enrolment.aggregate'
 
-// Cross-aggregate orchestration for a single manager action: mutating an enrolment while keeping the
-// synced `Member.type` cache in step. The route runs these inside its `withScopeFromContext` tx, so
-// any failure — the mutation, the recompute, or the role sync it triggers — rolls the whole change
-// back rather than leaving the stint and the cache disagreeing.
+// Cross-aggregate orchestration for a single manager action: mutating an enrolment, then bringing
+// the member's identity roles back in line with it. The route runs these inside its
+// `withScopeFromContext` tx, so any failure — the mutation or the role sync — rolls the whole change
+// back rather than leaving the stints and the role assignments disagreeing.
 //
-// Every mutation funnels through `_recomputeStandingType`, which re-derives the cache from the
-// member's surviving stints rather than reasoning about what the individual edit did. That matters
-// because an edit can change a stint's SHAPE — closing an ongoing one, reopening a closed one, or
-// changing an ongoing one's type — and each of those moves the cache in a different direction.
-// Deriving from the end state is the only version that stays correct for all of them.
+// Role assignments are stored rows, not a live view, so every mutation has to re-sync. The sync
+// re-reads the member's stints and derives their standing status itself, which is what makes this
+// correct for an edit that changes a stint's SHAPE — closing an ongoing one, reopening a closed one,
+// or changing an ongoing one's type each move the member's status a different way.
 
-async function _recomputeStandingType(
+function _syncMemberRoles(
   db: TransactionClient,
   memberId: number,
   congregationId: number,
   actorId: number,
 ): Promise<void> {
-  const stints = await db.pioneerEnrolment.findMany({
-    where: { memberId, congregationId },
-    select: { type: true, startMonth: true, startYear: true, endMonth: true, endYear: true, monthlyGoal: true },
-  })
-  await setPioneerType(db, memberId, congregationId, actorId, standingTypeFromEnrolments(stints))
+  return syncBuiltInRoleAssignments(db, memberId, congregationId, actorId)
 }
 
 export async function enrolPioneer(
@@ -43,7 +38,7 @@ export async function enrolPioneer(
   params: OpenEnrolmentParams,
 ): Promise<PioneerEnrolment> {
   const enrolment = await openEnrolment(db, memberId, congregationId, actorId, params)
-  await _recomputeStandingType(db, memberId, congregationId, actorId)
+  await _syncMemberRoles(db, memberId, congregationId, actorId)
   return enrolment
 }
 
@@ -55,7 +50,7 @@ export async function endPioneerEnrolment(
   end: { endMonth: number; endYear: number },
 ): Promise<PioneerEnrolment> {
   const enrolment = await closeEnrolment(db, enrolmentId, congregationId, actorId, end)
-  await _recomputeStandingType(db, enrolment.memberId, congregationId, actorId)
+  await _syncMemberRoles(db, enrolment.memberId, congregationId, actorId)
   return enrolment
 }
 
@@ -71,7 +66,7 @@ export async function updatePioneerEnrolment(
   params: UpdateEnrolmentParams,
 ): Promise<PioneerEnrolment> {
   const enrolment = await updateEnrolment(db, enrolmentId, congregationId, actorId, params)
-  await _recomputeStandingType(db, enrolment.memberId, congregationId, actorId)
+  await _syncMemberRoles(db, enrolment.memberId, congregationId, actorId)
   return enrolment
 }
 
@@ -83,6 +78,37 @@ export async function removePioneerEnrolment(
   actorId: number,
 ): Promise<PioneerEnrolment> {
   const removed = await deleteEnrolment(db, enrolmentId, congregationId, actorId)
-  await _recomputeStandingType(db, removed.memberId, congregationId, actorId)
+  await _syncMemberRoles(db, removed.memberId, congregationId, actorId)
   return removed
 }
+
+// Close every member's ongoing stint of one type, congregation-wide. Used when a congregation turns
+// off the permanent-auxiliary profile: those members stop being permanent auxiliaries, and the stint
+// is where that fact lives now. Only ONGOING stints match — a single-month auxiliary is already
+// closed and re-dating it would rewrite history that actually happened.
+//
+// Replaces member.aggregate's bulkUpdateType, which flipped the cached `Member.type` column and left
+// the stints open, so the two immediately disagreed.
+export async function endOngoingEnrolmentsOfType(
+  db: TransactionClient,
+  congregationId: number,
+  actorId: number,
+  type: PublisherType,
+  end: { endMonth: number; endYear: number },
+): Promise<number> {
+  const ongoing = await db.pioneerEnrolment.findMany({
+    where: { congregationId, type, endMonth: null, endYear: null },
+    select: { id: true, memberId: true },
+  })
+
+  for (const stint of ongoing) {
+    await closeEnrolment(db, stint.id, congregationId, actorId, end)
+  }
+  // Re-sync after all the closes, and once per member: a member cannot hold two ongoing stints, but
+  // syncing inside the loop would still be redundant work for no benefit.
+  for (const memberId of new Set(ongoing.map(s => s.memberId))) {
+    await _syncMemberRoles(db, memberId, congregationId, actorId)
+  }
+
+  return ongoing.length
+}
diff --git a/app/features/publishers/server/publishers.server.test.ts b/app/features/publishers/server/publishers.server.test.ts
index c5ebdbf6..ed16d178 100644
--- a/app/features/publishers/server/publishers.server.test.ts
+++ b/app/features/publishers/server/publishers.server.test.ts
@@ -99,7 +99,9 @@ describe('getPublishersWithGroup', () => {
     await getPublishersWithGroup(db, 1, { type: PublisherType.PionnierPermanant })
 
     const where = vi.mocked(db.member.findMany).mock.calls[0]?.[0]?.where
-    expect(where).toMatchObject({ type: PublisherType.PionnierPermanant })
+    expect(where).toMatchObject({
+      pioneerEnrolments: { some: { type: PublisherType.PionnierPermanant, endMonth: null } },
+    })
   })
 
   it('combines search, group and type filters', async () => {
@@ -115,7 +117,7 @@ describe('getPublishersWithGroup', () => {
       isPublisher: true,
       leftAt: null,
       publisherGroupId: { in: [42] },
-      type: PublisherType.Normal,
+      pioneerEnrolments: { none: { endMonth: null } },
       OR: [
         { firstname: { contains: 'jean', mode: 'insensitive' } },
         { lastname: { contains: 'jean', mode: 'insensitive' } },
diff --git a/app/features/publishers/server/publishers.server.ts b/app/features/publishers/server/publishers.server.ts
index 5ca5926c..bc3d5bb5 100644
--- a/app/features/publishers/server/publishers.server.ts
+++ b/app/features/publishers/server/publishers.server.ts
@@ -1,7 +1,9 @@
 import type { TransactionClient } from '~/shared/infra/db.server'
 import type { CongregationId, MemberId } from '~/shared/types/branded'
-import type { PublisherType } from '~/shared/types/publisher-type'
+import { PublisherType } from '~/shared/types/publisher-type'
 
+// Includes `pioneerEnrolments` because the S-21 export ticks a pioneer box from the member's
+// standing status, which is derived from the stints.
 export function getPublisherById(
   db: TransactionClient,
   publisherId: MemberId,
@@ -15,6 +17,7 @@ export function getPublisherById(
     include: {
       account: { select: { id: true, email: true, active: true } },
       publisherGroup: { include: { responsible: true, deputy: true } },
+      pioneerEnrolments: true,
       activities: {
         where: {
           OR: [
@@ -60,7 +63,14 @@ export async function getPublishersWithGroup(
   const groupFilter =
     options?.groupIds && options.groupIds.length > 0 ? { publisherGroupId: { in: options.groupIds } } : {}
 
-  const typeFilter = options?.type ? { type: options.type } : {}
+  // "Type" is the member's standing status, which lives on their stints: an ONGOING stint of that
+  // type, or — for Normal — no ongoing stint at all. A single-month auxiliary is closed, so it
+  // correctly leaves the member under Normal, exactly as the old `Member.type` column did.
+  const typeFilter = !options?.type
+    ? {}
+    : options.type === PublisherType.Normal
+      ? { pioneerEnrolments: { none: { endMonth: null } } }
+      : { pioneerEnrolments: { some: { type: options.type, endMonth: null } } }
 
   return await db.member.findMany({
     where: { isPublisher: true, leftAt: null, congregationId, ...searchFilter, ...groupFilter, ...typeFilter },
diff --git a/app/features/publishers/server/render-activity-pdf-zip.server.tsx b/app/features/publishers/server/render-activity-pdf-zip.server.tsx
index 6d5db080..9965b76d 100644
--- a/app/features/publishers/server/render-activity-pdf-zip.server.tsx
+++ b/app/features/publishers/server/render-activity-pdf-zip.server.tsx
@@ -1,11 +1,11 @@
 import { pdf } from '@react-pdf/renderer'
 import JsZip from 'jszip'
 import pLimit from 'p-limit'
-import type { Member, PublisherActivity } from '~/database/generated/client'
+import type { Member, PioneerEnrolment, PublisherActivity } from '~/database/generated/client'
 import { PublisherActivityDocument } from '~/features/publishers/ui/PublisherActivityDocument'
 import type { TransactionClient } from '~/shared/infra/db.server'
 
-type PublisherWithActivities = Member & { activities: PublisherActivity[] }
+type PublisherWithActivities = Member & { activities: PublisherActivity[]; pioneerEnrolments: PioneerEnrolment[] }
 
 export interface PublisherScopeOptions {
   groupId?: number
@@ -34,6 +34,9 @@ export async function getPublishersWithYearActivities(
     },
     include: {
       activities: { where: yearFilter },
+      // The S-21 sheet ticks a pioneer box from the member's standing status, which lives on the
+      // stints — without these every sheet would print unticked.
+      pioneerEnrolments: true,
     },
   })
 }
diff --git a/app/features/publishers/server/update-member.server.integration.test.ts b/app/features/publishers/server/update-member.server.integration.test.ts
index 54a688d4..907e1c27 100644
--- a/app/features/publishers/server/update-member.server.integration.test.ts
+++ b/app/features/publishers/server/update-member.server.integration.test.ts
@@ -52,7 +52,6 @@ beforeAll(async () => {
       isMale: true,
       // Elder + brother require baptism per the CHECK
       baptismDate: new Date('2010-01-01'),
-      type: PublisherType.Normal,
       congregationId,
     },
   })
diff --git a/app/features/publishers/server/update-member.server.test.ts b/app/features/publishers/server/update-member.server.test.ts
index 264a2dc6..abeb26dc 100644
--- a/app/features/publishers/server/update-member.server.test.ts
+++ b/app/features/publishers/server/update-member.server.test.ts
@@ -1,5 +1,4 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { PublisherType } from '~/shared/types/publisher-type'
 
 const mockMemberFindFirst = vi.fn()
 const mockMemberUpdate = vi.fn()
@@ -23,7 +22,6 @@ const { updateMember } = await import('./update-member.server')
 
 const BEFORE_IDENTITY = {
   isPublisher: true,
-  type: 'Normal',
   isMale: false,
   baptismDate: null,
   isAnointed: false,
@@ -49,7 +47,6 @@ describe('updateMember', () => {
     isServant: false,
     isAnointed: false,
     groupId: 5,
-    type: PublisherType.Normal,
     phone: '0612345678',
     address: '12 rue de la Paix',
   }
@@ -78,7 +75,6 @@ describe('updateMember', () => {
         isServant: false,
         isAnointed: false,
         publisherGroupId: 5,
-        type: PublisherType.Normal,
         address: '12 rue de la Paix',
         phone: '0612345678',
         email: 'jean@example.com',
diff --git a/app/features/publishers/ui/PublisherActivityDocument.tsx b/app/features/publishers/ui/PublisherActivityDocument.tsx
index 90a68d37..852de8b2 100644
--- a/app/features/publishers/ui/PublisherActivityDocument.tsx
+++ b/app/features/publishers/ui/PublisherActivityDocument.tsx
@@ -1,13 +1,16 @@
 import { Document, Page, Polygon, StyleSheet, Svg, Text, View } from '@react-pdf/renderer'
-import type { Member, PublisherActivity } from '~/database/generated/client'
+import type { Member, PioneerEnrolment, PublisherActivity } from '~/database/generated/client'
+import { standingTypeFromEnrolments } from '~/features/publishers/model/pioneer-enrolment'
 import * as m from '~/i18n/paraglide/messages'
 import { PublisherType } from '~/shared/types/publisher-type'
 
 interface PublisherActivityDocumentProps {
-  publisher: Member & { activities: PublisherActivity[] }
+  publisher: Member & { activities: PublisherActivity[]; pioneerEnrolments: PioneerEnrolment[] }
 }
 
 export function PublisherActivityDocument({ publisher }: PublisherActivityDocumentProps) {
+  // The pioneer boxes reflect the member's standing status, which is their ongoing stint.
+  const standingType = standingTypeFromEnrolments(publisher.pioneerEnrolments)
   const year = publisher.activities.reduce((acc, activity) => {
     if (activity.year < acc) {
       return activity.year
@@ -108,17 +111,17 @@ export function PublisherActivityDocument({ publisher }: PublisherActivityDocume
             <Text style={styles.label}>{m.activity_pdf_servant()}</Text>
           </View>
           <View style={styles.containerLabel}>
-            <Checkbox checked={publisher.type === PublisherType.PionnierPermanant} />
+            <Checkbox checked={standingType === PublisherType.PionnierPermanant} />
             <Text style={styles.label}>{m.activity_pdf_permanent_pioneer()}</Text>
           </View>
           <View style={styles.containerLabel}>
-            <Checkbox checked={publisher.type === PublisherType.PionnierSpecial} />
+            <Checkbox checked={standingType === PublisherType.PionnierSpecial} />
             <Text style={styles.label}>{m.activity_pdf_special_pioneer()}</Text>
           </View>
         </View>
         <View style={styles.checkboxLine}>
           <View style={styles.containerLabel}>
-            <Checkbox checked={publisher.type === PublisherType.Missionnaire} />
+            <Checkbox checked={standingType === PublisherType.Missionnaire} />
             <Text style={styles.label}>{m.activity_pdf_missionary()}</Text>
           </View>
         </View>
diff --git a/app/features/publishers/ui/PublisherFieldServiceForm.tsx b/app/features/publishers/ui/PublisherFieldServiceForm.tsx
index e35280d1..2b2da63e 100644
--- a/app/features/publishers/ui/PublisherFieldServiceForm.tsx
+++ b/app/features/publishers/ui/PublisherFieldServiceForm.tsx
@@ -2,7 +2,6 @@ import { useState } from 'react'
 import type { PublisherGroup } from '~/database/generated/client'
 
 import * as m from '~/i18n/paraglide/messages'
-import { PublisherType } from '~/shared/types/publisher-type'
 import type { UserInput } from '~/shared/types/user-input'
 import { Card, CardContent, CardHeader, CardTitle } from '~/shared/ui/card'
 import { Label } from '~/shared/ui/label'
@@ -11,20 +10,9 @@ import { formatGroupName } from '~/shared/utils/format-group-name'
 
 const NO_GROUP = '__none__'
 
-export default function PublisherFieldServiceForm({
-  user,
-  groups,
-  hideAuxiliaryPioneer = false,
-  hideTypeSelect = false,
-}: {
-  user?: UserInput
-  groups: PublisherGroup[]
-  hideAuxiliaryPioneer: boolean
-  // On the edit page the pioneer type is set via enrolment appointments (PioneerEnrolmentFields),
-  // not this dropdown — the current type is submitted as a hidden field so member updates preserve it.
-  hideTypeSelect?: boolean
-}) {
-  const [type, setType] = useState(user?.type ?? PublisherType.Normal)
+// Only the service group. A member's pioneer status is their enrolment, appointed from the
+// pioneer section of the edit page — there is no type to pick here.
+export default function PublisherFieldServiceForm({ user, groups }: { user?: UserInput; groups: PublisherGroup[] }) {
   const [group, setGroup] = useState(user?.publisherGroupId != null ? String(user.publisherGroupId) : NO_GROUP)
 
   return (
@@ -50,37 +38,6 @@ export default function PublisherFieldServiceForm({
             </SelectContent>
           </Select>
         </div>
-
-        {hideTypeSelect ? (
-          <input type="hidden" name="type" value={type} />
-        ) : (
-          <div className="space-y-2">
-            <Label htmlFor="type">{m.publishers_form_publisher_profile()}</Label>
-            <Select name="type" value={type} onValueChange={value => setType(value as PublisherType)}>
-              <SelectTrigger id="type" className="w-full">
-                <SelectValue />
-              </SelectTrigger>
-              <SelectContent>
-                <SelectItem value={PublisherType.Normal}>{m.publishers_form_profile_default()}</SelectItem>
-                {!hideAuxiliaryPioneer && (
-                  <SelectItem value={PublisherType.PionnierAuxiliaires}>
-                    {m.publishers_form_profile_auxiliary_pioneer()}
-                  </SelectItem>
-                )}
-                <SelectItem value={PublisherType.PionnierPermanant}>
-                  {m.publishers_form_profile_permanent_pioneer()}
-                </SelectItem>
-                <SelectItem value={PublisherType.PionnierSpecial}>
-                  {m.publishers_form_profile_special_pioneer()}
-                </SelectItem>
-                <SelectItem value={PublisherType.Missionnaire}>{m.publishers_form_profile_missionary()}</SelectItem>
-              </SelectContent>
-            </Select>
-            {type === PublisherType.PionnierAuxiliaires && (
-              <p className="text-muted-foreground text-xs italic">{m.publishers_form_auxiliary_pioneer_warning()}</p>
-            )}
-          </div>
-        )}
       </CardContent>
     </Card>
   )
diff --git a/app/features/settings/routes/users/add-to-congregation.tsx b/app/features/settings/routes/users/add-to-congregation.tsx
index a3f27530..d0e2dfef 100644
--- a/app/features/settings/routes/users/add-to-congregation.tsx
+++ b/app/features/settings/routes/users/add-to-congregation.tsx
@@ -15,7 +15,6 @@ import {
 import { ConflictError, NotFoundError } from '~/shared/errors/app-error.server'
 import type { AccountId } from '~/shared/types/branded'
 import { Permission } from '~/shared/types/permission'
-import { PublisherType } from '~/shared/types/publisher-type'
 import { Button } from '~/shared/ui/button'
 import { useFocusError } from '~/shared/ui/hooks/use-focus-error'
 import { Input } from '~/shared/ui/input'
@@ -181,7 +180,6 @@ export async function action({ request, params, context }: Route.ActionArgs) {
         birthDate: submission.value.birthDate ? new Date(submission.value.birthDate) : null,
         baptismDate: submission.value.baptismDate ? new Date(submission.value.baptismDate) : null,
         isPublisher: submission.value.isPublisher,
-        type: PublisherType.Normal,
         isHelder: false,
         isServant: false,
         isAnointed: false,
diff --git a/app/features/settings/server/congregation-settings.server.test.ts b/app/features/settings/server/congregation-settings.server.test.ts
index a88441a5..2192ef72 100644
--- a/app/features/settings/server/congregation-settings.server.test.ts
+++ b/app/features/settings/server/congregation-settings.server.test.ts
@@ -12,13 +12,13 @@ vi.mock('~/shared/domain/settings.server', () => ({
   setSetting: vi.fn(),
 }))
 vi.mock('~/shared/domain/audit.server', () => ({ AuditAction: {}, audit: vi.fn() }))
-vi.mock('~/shared/domain/built-in-roles.server', () => ({
-  syncBuiltInRoleAssignments: vi.fn(),
+vi.mock('~/features/publishers/index.server', () => ({
+  endOngoingEnrolmentsOfType: vi.fn(),
 }))
 
 const { updateCongregationSettings } = await import('./congregation-settings.server')
 const { setSetting } = await import('~/shared/domain/settings.server')
-const { syncBuiltInRoleAssignments } = await import('~/shared/domain/built-in-roles.server')
+const { endOngoingEnrolmentsOfType } = await import('~/features/publishers/index.server')
 
 const mockDb = {
   member: {
@@ -41,62 +41,27 @@ describe('updateCongregationSettings', () => {
     })
 
     expect(setSetting).toHaveBeenCalledWith(mockDb, 'auxiliary-pioneer-profile-active', 'true', 10)
-    expect(mockDb.member.updateMany).not.toHaveBeenCalled()
-    expect(syncBuiltInRoleAssignments).not.toHaveBeenCalled()
+    expect(endOngoingEnrolmentsOfType).not.toHaveBeenCalled()
   })
 
-  it('resets auxiliary pioneers to normal when feature is deactivated', async () => {
+  // Deactivating the profile means those members stop being permanent auxiliaries. That fact lives
+  // on the stint now, so the setting closes the ongoing ones instead of flipping a cached column.
+  // Re-syncing each affected member's roles is guaranteed inside endOngoingEnrolmentsOfType and
+  // covered by pioneer-enrolment.workflow.integration.test.ts — the regression this file used to
+  // guard (a bulk type flip that skipped the role sync) cannot recur, because there is no bulk flip.
+  it('closes ongoing auxiliary enrolments when the profile is deactivated', async () => {
     vi.mocked(setSetting).mockResolvedValue(undefined as never)
-    mockDb.member.updateMany.mockResolvedValue({ count: 3 })
 
     await updateCongregationSettings(mockDb as never, 10, 99, {
       auxiliaryPioneerProfileActivated: 'false',
     })
 
-    expect(mockDb.member.updateMany).toHaveBeenCalledWith({
-      where: {
-        congregationId: 10,
-        type: PublisherType.PionnierAuxiliaires,
-      },
-      data: {
-        type: PublisherType.Normal,
-      },
-    })
-  })
-
-  // Wave 1 bug 1 — regression test.
-  // The bulk `updateMany` flips Member.type but used to skip
-  // `syncBuiltInRoleAssignments`, leaving stale `pioneer` role assignments
-  // for every member whose type was reset.
-  it('syncs built-in roles for every member whose type was reset', async () => {
-    vi.mocked(setSetting).mockResolvedValue(undefined as never)
-    mockDb.member.findMany.mockResolvedValue([{ id: 100 }, { id: 200 }, { id: 300 }])
-    mockDb.member.updateMany.mockResolvedValue({ count: 3 })
-
-    await updateCongregationSettings(mockDb as never, 10, 99, {
-      auxiliaryPioneerProfileActivated: 'false',
-    })
-
-    expect(mockDb.member.findMany).toHaveBeenCalledWith({
-      where: { congregationId: 10, type: PublisherType.PionnierAuxiliaires },
-      select: { id: true },
-    })
-    expect(syncBuiltInRoleAssignments).toHaveBeenCalledTimes(3)
-    expect(syncBuiltInRoleAssignments).toHaveBeenNthCalledWith(1, mockDb, 100, 10, 99)
-    expect(syncBuiltInRoleAssignments).toHaveBeenNthCalledWith(2, mockDb, 200, 10, 99)
-    expect(syncBuiltInRoleAssignments).toHaveBeenNthCalledWith(3, mockDb, 300, 10, 99)
-  })
-
-  it('does not sync when no auxiliary pioneers exist to reset', async () => {
-    vi.mocked(setSetting).mockResolvedValue(undefined as never)
-    mockDb.member.findMany.mockResolvedValue([])
-    mockDb.member.updateMany.mockResolvedValue({ count: 0 })
-
-    await updateCongregationSettings(mockDb as never, 10, 99, {
-      auxiliaryPioneerProfileActivated: 'false',
-    })
-
-    expect(mockDb.member.updateMany).toHaveBeenCalled()
-    expect(syncBuiltInRoleAssignments).not.toHaveBeenCalled()
+    expect(endOngoingEnrolmentsOfType).toHaveBeenCalledWith(
+      mockDb,
+      10,
+      99,
+      PublisherType.PionnierAuxiliaires,
+      expect.objectContaining({ endMonth: expect.any(Number), endYear: expect.any(Number) }),
+    )
   })
 })
diff --git a/app/features/settings/server/congregation-settings.server.ts b/app/features/settings/server/congregation-settings.server.ts
index 33fe372a..4b0fb8eb 100644
--- a/app/features/settings/server/congregation-settings.server.ts
+++ b/app/features/settings/server/congregation-settings.server.ts
@@ -1,4 +1,4 @@
-import { memberAggregate } from '~/features/publishers/index.server'
+import { endOngoingEnrolmentsOfType } from '~/features/publishers/index.server'
 import { AuditAction, audit } from '~/shared/domain/audit.server'
 import { setSetting } from '~/shared/domain/settings.server'
 import type { TransactionClient } from '~/shared/infra/db.server'
@@ -21,13 +21,14 @@ export async function updateCongregationSettings(
   )
 
   if (data.auxiliaryPioneerProfileActivated === 'false') {
-    await memberAggregate.bulkUpdateType(
-      db,
-      congregationId,
-      actorId,
-      PublisherType.PionnierAuxiliaires,
-      PublisherType.Normal,
-    )
+    // Turning the profile off means these members stop being permanent auxiliaries. That fact lives
+    // on the stint now, so close the ongoing ones at the current month rather than flipping a cached
+    // column — closing keeps the history of what they actually did.
+    const now = new Date()
+    await endOngoingEnrolmentsOfType(db, congregationId, actorId, PublisherType.PionnierAuxiliaires, {
+      endMonth: now.getMonth(),
+      endYear: now.getFullYear(),
+    })
   }
 
   audit({
diff --git a/app/features/settings/server/export-congregation.server.ts b/app/features/settings/server/export-congregation.server.ts
index 82972577..76de0bf8 100644
--- a/app/features/settings/server/export-congregation.server.ts
+++ b/app/features/settings/server/export-congregation.server.ts
@@ -150,7 +150,6 @@ export function buildExportSteps(db: TransactionClient, congregationId: number,
             firstname: true,
             lastname: true,
             isPublisher: true,
-            type: true,
             isMale: true,
             phone: true,
             address: true,
diff --git a/app/features/settings/server/import-user-accounts.server.ts b/app/features/settings/server/import-user-accounts.server.ts
index 366a0a81..58a6f181 100644
--- a/app/features/settings/server/import-user-accounts.server.ts
+++ b/app/features/settings/server/import-user-accounts.server.ts
@@ -3,7 +3,6 @@ import { syncBuiltInRoleAssignments } from '~/shared/domain/built-in-roles.serve
 import { ensureAdminRole } from '~/shared/domain/setup.server'
 import type { TransactionClient } from '~/shared/infra/db.server'
 import { createLogger } from '~/shared/infra/logger.server'
-import type { PublisherType } from '~/shared/types/publisher-type'
 import { stripDiacritics } from '~/shared/utils/strip-diacritics'
 import type { EntityIdMap } from './data-transfer.type'
 import { readNdjsonFile } from './ndjson-archive'
@@ -63,7 +62,6 @@ export async function importMembers(
         firstnameNormalized: stripDiacritics(record.firstname),
         lastnameNormalized: stripDiacritics(record.lastname),
         isPublisher: record.isPublisher,
-        type: record.type as PublisherType,
         isMale: record.isMale,
         phone: record.phone,
         address: record.address,
diff --git a/app/features/settings/server/link-member-to-account.server.ts b/app/features/settings/server/link-member-to-account.server.ts
index 70107018..39d0b22b 100644
--- a/app/features/settings/server/link-member-to-account.server.ts
+++ b/app/features/settings/server/link-member-to-account.server.ts
@@ -5,7 +5,6 @@ import { LimitService } from '~/shared/domain/limits.server'
 import { ConflictError, NotFoundError } from '~/shared/errors/app-error.server'
 import type { TransactionClient } from '~/shared/infra/db.server'
 import type { AccountId } from '~/shared/types/branded'
-import type { PublisherType } from '~/shared/types/publisher-type'
 
 export interface LinkMemberToAccountParams {
   accountId: AccountId
@@ -19,7 +18,6 @@ export interface LinkMemberToAccountParams {
   birthDate: Date | null
   baptismDate: Date | null
   isPublisher: boolean
-  type: PublisherType
   isHelder: boolean
   isServant: boolean
   isAnointed: boolean
@@ -62,7 +60,6 @@ export async function linkMemberToAccount(
     birthDate: params.birthDate,
     baptismDate: params.baptismDate,
     isPublisher: params.isPublisher,
-    type: params.type,
     isHelder: params.isHelder,
     isServant: params.isServant,
     isAnointed: params.isAnointed,
diff --git a/app/features/settings/server/migrate-legacy-users-ndjson.server.ts b/app/features/settings/server/migrate-legacy-users-ndjson.server.ts
index 6bea77ac..2ffd8747 100644
--- a/app/features/settings/server/migrate-legacy-users-ndjson.server.ts
+++ b/app/features/settings/server/migrate-legacy-users-ndjson.server.ts
@@ -85,7 +85,6 @@ export async function migrateLegacyUsersNdjson(zip: JsZip, manifestVersion: stri
         firstname: row.firstname ?? '',
         lastname: row.lastname ?? '',
         isPublisher: row.isPublisher,
-        type: row.type ?? 'normal',
         isMale: row.isMale ?? null,
         phone: row.phone ?? '',
         address: row.address ?? '',
diff --git a/app/shared/domain/built-in-roles.server.integration.test.ts b/app/shared/domain/built-in-roles.server.integration.test.ts
index f1bb0fe5..77a1e13d 100644
--- a/app/shared/domain/built-in-roles.server.integration.test.ts
+++ b/app/shared/domain/built-in-roles.server.integration.test.ts
@@ -62,7 +62,6 @@ beforeAll(async () => {
       lastname: 'Primary',
       isPublisher: true,
       isMale: false,
-      type: PublisherType.Normal,
       congregationId: primaryCongId,
     },
   })
@@ -77,7 +76,6 @@ beforeAll(async () => {
       isHelder: true,
       // Elder requires baptism
       baptismDate: new Date('2000-01-01'),
-      type: PublisherType.Normal,
       congregationId: otherCongId,
     },
   })
@@ -188,15 +186,14 @@ describe('syncBuiltInRoleAssignments (integration)', () => {
     expect(vi.mocked(audit).mock.calls.length).toBe(callsAfterIdempotentRun)
   })
 
-  // The pioneer role is derived from the member's enrolment stints, not the Member.type column.
-  // These two pin that: the column is deliberately contradicted in each direction.
-  it('attaches the pioneer role from an ongoing enrolment even when the type column says Normal', async () => {
+  // The pioneer role is derived from the member's enrolment stints. These two pin both directions:
+  // a stint grants it, the absence of one withholds it.
+  it('attaches the pioneer role from an ongoing enrolment', async () => {
     const member = await testDb.member.create({
       data: {
         firstname: 'Enrolled',
         lastname: `Pioneer-${ts}`,
         isPublisher: true,
-        type: PublisherType.Normal,
         baptismDate: new Date('2015-01-01'),
         congregationId: primaryCongId,
       },
@@ -220,13 +217,12 @@ describe('syncBuiltInRoleAssignments (integration)', () => {
     expect(assignments.map(a => a.role.key)).toContain('pioneer')
   })
 
-  it('withholds the pioneer role when only the type column says pioneer and no stint exists', async () => {
+  it('withholds the pioneer role from a member with no stint at all', async () => {
     const member = await testDb.member.create({
       data: {
         firstname: 'Stale',
         lastname: `Cache-${ts}`,
         isPublisher: true,
-        type: PublisherType.PionnierPermanant,
         baptismDate: new Date('2015-01-01'),
         congregationId: primaryCongId,
       },

From 7d30c9762a348b02a8dff07df2bf67f8d2f41a62 Mon Sep 17 00:00:00 2001
From: mindsers <nathanael@cherrier.dev>
Date: Mon, 31 Aug 2026 21:25:33 +0200
Subject: [PATCH 2/2] fix(publishers): timezone and future-dated stints in the
 bulk auxiliary close
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Two real defects from review, both in the path that runs when a congregation turns
off the permanent-auxiliary profile.

A future-dated stint made the whole settings save fail. The create form offers start
years from -2 to +2, so an auxiliary appointment can be dated ahead. Closing it at
the current month is an end before its start, which closeEnrolment rejects — and
because the close runs congregation-wide, that one stint threw and took every other
member's close with it. Stints that have not started are now left open and counted
in the return value rather than attempted.

The close month came from the server's clock. Closing picks a MONTH, so a server an
hour either side of midnight on the 1st dated it to the wrong one. It now takes the
congregation's clock via zonedNow, matching how pioneer-goals and the dashboard
already resolve "now" for congregation-scoped work.

Also from review:
- An integration test for the standing-type filter. The unit test asserts the `where`
  shape, which cannot tell whether Prisma builds SQL that selects the right people —
  and this branch already produced three column reads that typechecked and failed
  only at runtime. It pins that a closed single-month auxiliary reads as Normal.
- A test that the bulk close spans several members, which the single-member cases
  never exercised.
- `getPublishersWithGroup`'s filter option is now `standingType`, matching the rename
  the role predicate already took; it selects on stints, not on a member field.
- The S-21 export selects only the stint fields it reads, via an ENROLMENT_PERIOD_SELECT
  kept beside EnrolmentPeriod so the two cannot drift. It was fetching whole rows for
  every publisher in a congregation-wide zip to read three fields.
- Eight test names still described setting `Member.type`; they assert standing status.
---
 .../publishers/model/pioneer-enrolment.ts     | 11 +++
 .../routes/publishers/publisher-list.tsx      |  2 +-
 ...eer-enrolment.workflow.integration.test.ts | 76 +++++++++++++++---
 .../server/pioneer-enrolment.workflow.ts      | 20 +++--
 .../server/publishers.integration.test.ts     | 79 +++++++++++++++++++
 .../server/publishers.server.test.ts          |  4 +-
 .../publishers/server/publishers.server.ts    | 11 +--
 .../server/render-activity-pdf-zip.server.tsx |  9 ++-
 .../ui/PublisherActivityDocument.tsx          |  6 +-
 .../settings/routes/congregation/settings.tsx | 11 ++-
 .../congregation-settings.server.test.ts      | 14 ++--
 .../server/congregation-settings.server.ts    |  4 +-
 12 files changed, 204 insertions(+), 43 deletions(-)

diff --git a/app/features/publishers/model/pioneer-enrolment.ts b/app/features/publishers/model/pioneer-enrolment.ts
index 6fa843ef..73c712f0 100644
--- a/app/features/publishers/model/pioneer-enrolment.ts
+++ b/app/features/publishers/model/pioneer-enrolment.ts
@@ -6,6 +6,17 @@
 import { PublisherType } from '~/shared/types/publisher-type'
 import { type MonthRef, serviceYearMonths } from './pioneer-pace'
 
+// The Prisma `select` that produces an EnrolmentPeriod. Kept beside the type so a schema change
+// cannot leave a caller selecting a shape the helpers no longer accept.
+export const ENROLMENT_PERIOD_SELECT = {
+  type: true,
+  startMonth: true,
+  startYear: true,
+  endMonth: true,
+  endYear: true,
+  monthlyGoal: true,
+} as const
+
 // A pioneer stint, DB-free and serialisable — mirrors the PioneerEnrolment row's period fields.
 export interface EnrolmentPeriod {
   type: PublisherType
diff --git a/app/features/publishers/routes/publishers/publisher-list.tsx b/app/features/publishers/routes/publishers/publisher-list.tsx
index 2e45679b..9d059239 100644
--- a/app/features/publishers/routes/publishers/publisher-list.tsx
+++ b/app/features/publishers/routes/publishers/publisher-list.tsx
@@ -53,7 +53,7 @@ export function loader({ request, context }: Route.LoaderArgs) {
 
   return withScopeFromContext(context, async db => {
     const [users, groups] = await Promise.all([
-      getPublishersWithGroup(db, currentUser.congregationId, { search, groupIds, type }),
+      getPublishersWithGroup(db, currentUser.congregationId, { search, groupIds, standingType: type }),
       db.publisherGroup.findMany({
         where: { congregationId: currentUser.congregationId },
         select: { id: true, name: true },
diff --git a/app/features/publishers/server/pioneer-enrolment.workflow.integration.test.ts b/app/features/publishers/server/pioneer-enrolment.workflow.integration.test.ts
index 522cd5d8..78ca60fa 100644
--- a/app/features/publishers/server/pioneer-enrolment.workflow.integration.test.ts
+++ b/app/features/publishers/server/pioneer-enrolment.workflow.integration.test.ts
@@ -82,7 +82,7 @@ async function standingTypeOf(memberId: number): Promise<PublisherType> {
 }
 
 describe('pioneer-enrolment workflow (integration)', () => {
-  it('an ongoing ANNUAL enrol sets Member.type and attaches the pioneer role', async () => {
+  it('an ongoing ANNUAL enrol gives the member a standing status and attaches the pioneer role', async () => {
     const memberId = await makePublisher(`Annual-${ts}`)
     await withScope(congId, tx =>
       enrolPioneer(tx, memberId, congId, 1, { type: PublisherType.PionnierPermanant, startMonth: 8, startYear: 2025 }),
@@ -91,7 +91,7 @@ describe('pioneer-enrolment workflow (integration)', () => {
     expect(await pioneerRoleAttached(memberId)).toBe(true)
   })
 
-  it('an ongoing PERMANENT-AUXILIARY enrol sets Member.type to PionnierAuxiliaires', async () => {
+  it('an ongoing PERMANENT-AUXILIARY enrol makes the standing status PionnierAuxiliaires', async () => {
     const memberId = await makePublisher(`PermAux-${ts}`)
     await withScope(congId, tx =>
       enrolPioneer(tx, memberId, congId, 1, {
@@ -104,7 +104,7 @@ describe('pioneer-enrolment workflow (integration)', () => {
     expect(await pioneerRoleAttached(memberId)).toBe(true)
   })
 
-  it('a SINGLE-MONTH auxiliary enrol leaves Member.type as Normal', async () => {
+  it('a SINGLE-MONTH auxiliary enrol leaves the standing status Normal', async () => {
     const memberId = await makePublisher(`Monthly-${ts}`)
     await withScope(congId, tx =>
       enrolPioneer(tx, memberId, congId, 1, {
@@ -118,13 +118,13 @@ describe('pioneer-enrolment workflow (integration)', () => {
     )
     expect(await standingTypeOf(memberId)).toBe(PublisherType.Normal)
     expect(await pioneerRoleAttached(memberId)).toBe(false)
-    // The enrolment record still exists (status is read from it, not from Member.type).
+    // The enrolment record still exists — the standing status is read from it.
     const enrolments = await testDb.pioneerEnrolment.findMany({ where: { memberId } })
     expect(enrolments).toHaveLength(1)
     expect(enrolments[0].monthlyGoal).toBe(15)
   })
 
-  it('closing the last ongoing stint reverts Member.type to Normal', async () => {
+  it('closing the last ongoing stint returns the standing status to Normal', async () => {
     const memberId = await makePublisher(`Close-${ts}`)
     const enrolment = await withScope(congId, tx =>
       enrolPioneer(tx, memberId, congId, 1, { type: PublisherType.PionnierPermanant, startMonth: 8, startYear: 2025 }),
@@ -156,7 +156,7 @@ describe('pioneer-enrolment workflow (integration)', () => {
     expect(await standingTypeOf(memberId)).toBe(PublisherType.Normal)
   })
 
-  it('removing the last ongoing stint reverts Member.type to Normal', async () => {
+  it('removing the last ongoing stint returns the standing status to Normal', async () => {
     const memberId = await makePublisher(`RemoveStanding-${ts}`)
     const enrolment = await withScope(congId, tx =>
       enrolPioneer(tx, memberId, congId, 1, { type: PublisherType.PionnierPermanant, startMonth: 8, startYear: 2025 }),
@@ -169,9 +169,9 @@ describe('pioneer-enrolment workflow (integration)', () => {
     expect(await pioneerRoleAttached(memberId)).toBe(false)
   })
 
-  // A period edit can flip a stint's shape, which is exactly what the Member.type cache keys on.
+  // A period edit can flip a stint's shape, which is what the member's standing status turns on.
   // These three are the cases updateEnrolment could not previously be trusted with.
-  it('adding an end date to the only ongoing stint reverts Member.type and detaches the role', async () => {
+  it('adding an end date to the only ongoing stint drops the standing status and detaches the role', async () => {
     const memberId = await makePublisher(`UpdateClose-${ts}`)
     const enrolment = await withScope(congId, tx =>
       enrolPioneer(tx, memberId, congId, 1, {
@@ -195,7 +195,7 @@ describe('pioneer-enrolment workflow (integration)', () => {
     expect(await pioneerRoleAttached(memberId)).toBe(false)
   })
 
-  it('clearing the end date reopens the stint and restores Member.type', async () => {
+  it('clearing the end date reopens the stint and restores the standing status', async () => {
     const memberId = await makePublisher(`UpdateReopen-${ts}`)
     const enrolment = await withScope(congId, tx =>
       enrolPioneer(tx, memberId, congId, 1, {
@@ -216,7 +216,7 @@ describe('pioneer-enrolment workflow (integration)', () => {
     expect(await pioneerRoleAttached(memberId)).toBe(true)
   })
 
-  it('correcting an ongoing stint`s type moves Member.type with it', async () => {
+  it('correcting an ongoing stint`s type moves the standing status with it', async () => {
     const memberId = await makePublisher(`UpdateType-${ts}`)
     const enrolment = await withScope(congId, tx =>
       enrolPioneer(tx, memberId, congId, 1, {
@@ -303,4 +303,60 @@ describe('pioneer-enrolment workflow (integration)', () => {
     expect(stints[0].endMonth).toBe(3)
     expect(stints[0].endYear).toBe(2026)
   })
+
+  // The create form offers start years from -2 to +2, so an appointment can be dated ahead. Closing
+  // it at the current month would be `end < start`, which closeEnrolment rejects — and the throw
+  // would take the whole settings save with it, not just this stint.
+  it('endOngoingEnrolmentsOfType leaves a future-dated stint alone instead of failing', async () => {
+    const future = await makePublisher(`BulkFuture-${ts}`)
+    const current = await makePublisher(`BulkCurrent-${ts}`)
+    await withScope(congId, tx =>
+      enrolPioneer(tx, future, congId, 1, {
+        type: PublisherType.PionnierAuxiliaires,
+        startMonth: 5,
+        startYear: 2027,
+      }),
+    )
+    await withScope(congId, tx =>
+      enrolPioneer(tx, current, congId, 1, {
+        type: PublisherType.PionnierAuxiliaires,
+        startMonth: 8,
+        startYear: 2025,
+      }),
+    )
+
+    await withScope(congId, tx =>
+      endOngoingEnrolmentsOfType(tx, congId, 1, PublisherType.PionnierAuxiliaires, { endMonth: 10, endYear: 2025 }),
+    )
+
+    // The one that had started is closed; the future one is untouched and still ongoing.
+    const closed = await testDb.pioneerEnrolment.findFirst({ where: { memberId: current, congregationId: congId } })
+    expect(closed?.endMonth).toBe(10)
+    const untouched = await testDb.pioneerEnrolment.findFirst({ where: { memberId: future, congregationId: congId } })
+    expect(untouched?.endMonth).toBeNull()
+  })
+
+  // Each affected member is synced once, not once per stint — exercised across members, since the
+  // non-overlap invariant means one member can never hold two ongoing stints.
+  it('endOngoingEnrolmentsOfType closes stints for several members', async () => {
+    const a = await makePublisher(`BulkA-${ts}`)
+    const b = await makePublisher(`BulkB-${ts}`)
+    for (const id of [a, b]) {
+      await withScope(congId, tx =>
+        enrolPioneer(tx, id, congId, 1, {
+          type: PublisherType.PionnierAuxiliaires,
+          startMonth: 8,
+          startYear: 2025,
+        }),
+      )
+    }
+
+    const closed = await withScope(congId, tx =>
+      endOngoingEnrolmentsOfType(tx, congId, 1, PublisherType.PionnierAuxiliaires, { endMonth: 10, endYear: 2025 }),
+    )
+
+    expect(closed).toEqual({ closed: 2, skippedFutureDated: expect.any(Number) })
+    expect(await pioneerRoleAttached(a)).toBe(false)
+    expect(await pioneerRoleAttached(b)).toBe(false)
+  })
 })
diff --git a/app/features/publishers/server/pioneer-enrolment.workflow.ts b/app/features/publishers/server/pioneer-enrolment.workflow.ts
index 8bd70c25..9c4f4cb8 100644
--- a/app/features/publishers/server/pioneer-enrolment.workflow.ts
+++ b/app/features/publishers/server/pioneer-enrolment.workflow.ts
@@ -55,9 +55,9 @@ export async function endPioneerEnrolment(
 }
 
 // Edit a stint's period (and optionally its type). No route posts to this yet — the edit UI is a
-// follow-up; it is here because the recompute is what makes such a route safe to add. The period edit is what makes the recompute
-// load-bearing: adding an end date to the member's only ongoing stint has to drop the cache back to
-// Normal, and clearing one has to raise it again.
+// follow-up; it is here because the role re-sync is what makes such a route safe to add. A period
+// edit is what makes that load-bearing: adding an end date to the member's only ongoing stint has to
+// drop their standing status, and clearing one has to restore it.
 export async function updatePioneerEnrolment(
   db: TransactionClient,
   enrolmentId: number,
@@ -95,11 +95,17 @@ export async function endOngoingEnrolmentsOfType(
   actorId: number,
   type: PublisherType,
   end: { endMonth: number; endYear: number },
-): Promise<number> {
-  const ongoing = await db.pioneerEnrolment.findMany({
+): Promise<{ closed: number; skippedFutureDated: number }> {
+  // Starts on or before the end date. A stint dated ahead (the create form offers ±2 years) cannot
+  // be closed at `end` — closeEnrolment rejects an end before the start — and because this runs
+  // congregation-wide, one such stint would throw and take the entire settings save with it rather
+  // than just itself. Those are left open and reported in the return value.
+  const endAbs = end.endYear * 12 + end.endMonth
+  const allOngoing = await db.pioneerEnrolment.findMany({
     where: { congregationId, type, endMonth: null, endYear: null },
-    select: { id: true, memberId: true },
+    select: { id: true, memberId: true, startMonth: true, startYear: true },
   })
+  const ongoing = allOngoing.filter(s => s.startYear * 12 + s.startMonth <= endAbs)
 
   for (const stint of ongoing) {
     await closeEnrolment(db, stint.id, congregationId, actorId, end)
@@ -110,5 +116,5 @@ export async function endOngoingEnrolmentsOfType(
     await _syncMemberRoles(db, memberId, congregationId, actorId)
   }
 
-  return ongoing.length
+  return { closed: ongoing.length, skippedFutureDated: allOngoing.length - ongoing.length }
 }
diff --git a/app/features/publishers/server/publishers.integration.test.ts b/app/features/publishers/server/publishers.integration.test.ts
index 59de1d47..c1ba2399 100644
--- a/app/features/publishers/server/publishers.integration.test.ts
+++ b/app/features/publishers/server/publishers.integration.test.ts
@@ -2,6 +2,7 @@ import { PrismaPg } from '@prisma/adapter-pg'
 import { afterAll, beforeAll, describe, expect, it } from 'vitest'
 import { PrismaClient } from '~/database/generated/client'
 import type { CongregationId, MemberId } from '~/shared/types/branded'
+import { PublisherType } from '~/shared/types/publisher-type'
 import { createTestCongregation, createTestUser } from '~/tests/factories'
 import { getPublisherById, getPublishersWithGroup } from './publishers.server'
 
@@ -135,3 +136,81 @@ describe('getPublishersWithGroup search filter', () => {
     expect(result).toHaveLength(2)
   })
 })
+
+// The type filter moved from a Member column to a condition over PioneerEnrolment stints. The unit
+// test asserts the `where` SHAPE, which cannot tell whether Prisma builds SQL that actually selects
+// the right people — and this branch already produced three column reads that typechecked and failed
+// only at runtime. So exercise it against the database.
+describe('getPublishersWithGroup — filtering by standing type (integration)', () => {
+  const ts = Date.now()
+  let congId: number
+  let permanentId: number
+  let monthlyAuxId: number
+  let plainId: number
+
+  beforeAll(async () => {
+    const cong = await createTestCongregation(testDb, { name: `TypeFilter ${ts}`, slug: `type-filter-${ts}` })
+    congId = cong.id
+
+    const permanent = await createTestUser(testDb, congId, { isPublisher: true, firstname: `Perm${ts}` })
+    permanentId = permanent.memberId ?? permanent.id
+    const monthly = await createTestUser(testDb, congId, { isPublisher: true, firstname: `Month${ts}` })
+    monthlyAuxId = monthly.memberId ?? monthly.id
+    const plain = await createTestUser(testDb, congId, { isPublisher: true, firstname: `Plain${ts}` })
+    plainId = plain.memberId ?? plain.id
+
+    await testDb.pioneerEnrolment.createMany({
+      data: [
+        // Ongoing permanent pioneer.
+        {
+          memberId: permanentId,
+          congregationId: congId,
+          type: PublisherType.PionnierPermanant,
+          startMonth: 8,
+          startYear: 2025,
+        },
+        // Single-month auxiliary: closed, so this member is NOT a standing auxiliary.
+        {
+          memberId: monthlyAuxId,
+          congregationId: congId,
+          type: PublisherType.PionnierAuxiliaires,
+          startMonth: 4,
+          startYear: 2026,
+          endMonth: 4,
+          endYear: 2026,
+        },
+      ],
+    })
+  })
+
+  afterAll(async () => {
+    await testDb.pioneerEnrolment.deleteMany({ where: { congregationId: congId } })
+    await testDb.userAccount.deleteMany({ where: { congregationId: congId } })
+    await testDb.member.deleteMany({ where: { congregationId: congId } })
+    await testDb.congregation.deleteMany({ where: { id: congId } })
+  })
+
+  it('returns only the member with an ongoing stint of that type', async () => {
+    const result = await withScope(congId, tx =>
+      getPublishersWithGroup(tx, congId, { standingType: PublisherType.PionnierPermanant }),
+    )
+    expect(result.map(r => r.id)).toEqual([permanentId])
+  })
+
+  it('returns nobody for a type nobody currently holds', async () => {
+    const result = await withScope(congId, tx =>
+      getPublishersWithGroup(tx, congId, { standingType: PublisherType.Missionnaire }),
+    )
+    expect(result).toEqual([])
+  })
+
+  // The behaviour the old column had: a single-month auxiliary is closed, so its holder reads Normal.
+  it('counts a member whose only stint is a closed single-month auxiliary as Normal', async () => {
+    const result = await withScope(congId, tx =>
+      getPublishersWithGroup(tx, congId, { standingType: PublisherType.Normal }),
+    )
+    const ids = result.map(r => r.id).sort((a, b) => a - b)
+    expect(ids).toEqual([monthlyAuxId, plainId].sort((a, b) => a - b))
+    expect(ids).not.toContain(permanentId)
+  })
+})
diff --git a/app/features/publishers/server/publishers.server.test.ts b/app/features/publishers/server/publishers.server.test.ts
index ed16d178..5a097fff 100644
--- a/app/features/publishers/server/publishers.server.test.ts
+++ b/app/features/publishers/server/publishers.server.test.ts
@@ -96,7 +96,7 @@ describe('getPublishersWithGroup', () => {
 
   it('narrows the where clause to the provided publisher type', async () => {
     vi.mocked(db.member.findMany).mockResolvedValue([] as never)
-    await getPublishersWithGroup(db, 1, { type: PublisherType.PionnierPermanant })
+    await getPublishersWithGroup(db, 1, { standingType: PublisherType.PionnierPermanant })
 
     const where = vi.mocked(db.member.findMany).mock.calls[0]?.[0]?.where
     expect(where).toMatchObject({
@@ -109,7 +109,7 @@ describe('getPublishersWithGroup', () => {
     await getPublishersWithGroup(db, 1, {
       search: 'jean',
       groupIds: [42],
-      type: PublisherType.Normal,
+      standingType: PublisherType.Normal,
     })
 
     const where = vi.mocked(db.member.findMany).mock.calls[0]?.[0]?.where
diff --git a/app/features/publishers/server/publishers.server.ts b/app/features/publishers/server/publishers.server.ts
index bc3d5bb5..3be3ad54 100644
--- a/app/features/publishers/server/publishers.server.ts
+++ b/app/features/publishers/server/publishers.server.ts
@@ -1,6 +1,7 @@
 import type { TransactionClient } from '~/shared/infra/db.server'
 import type { CongregationId, MemberId } from '~/shared/types/branded'
 import { PublisherType } from '~/shared/types/publisher-type'
+import { ENROLMENT_PERIOD_SELECT } from '../model/pioneer-enrolment'
 
 // Includes `pioneerEnrolments` because the S-21 export ticks a pioneer box from the member's
 // standing status, which is derived from the stints.
@@ -17,7 +18,7 @@ export function getPublisherById(
     include: {
       account: { select: { id: true, email: true, active: true } },
       publisherGroup: { include: { responsible: true, deputy: true } },
-      pioneerEnrolments: true,
+      pioneerEnrolments: { select: ENROLMENT_PERIOD_SELECT },
       activities: {
         where: {
           OR: [
@@ -49,7 +50,7 @@ export async function getPublishers(
 export async function getPublishersWithGroup(
   db: TransactionClient,
   congregationId: number,
-  options?: { search?: string; groupIds?: number[]; type?: PublisherType },
+  options?: { search?: string; groupIds?: number[]; standingType?: PublisherType },
 ) {
   const searchFilter = options?.search
     ? {
@@ -66,11 +67,11 @@ export async function getPublishersWithGroup(
   // "Type" is the member's standing status, which lives on their stints: an ONGOING stint of that
   // type, or — for Normal — no ongoing stint at all. A single-month auxiliary is closed, so it
   // correctly leaves the member under Normal, exactly as the old `Member.type` column did.
-  const typeFilter = !options?.type
+  const typeFilter = !options?.standingType
     ? {}
-    : options.type === PublisherType.Normal
+    : options.standingType === PublisherType.Normal
       ? { pioneerEnrolments: { none: { endMonth: null } } }
-      : { pioneerEnrolments: { some: { type: options.type, endMonth: null } } }
+      : { pioneerEnrolments: { some: { type: options.standingType, endMonth: null } } }
 
   return await db.member.findMany({
     where: { isPublisher: true, leftAt: null, congregationId, ...searchFilter, ...groupFilter, ...typeFilter },
diff --git a/app/features/publishers/server/render-activity-pdf-zip.server.tsx b/app/features/publishers/server/render-activity-pdf-zip.server.tsx
index 9965b76d..5f8fa581 100644
--- a/app/features/publishers/server/render-activity-pdf-zip.server.tsx
+++ b/app/features/publishers/server/render-activity-pdf-zip.server.tsx
@@ -1,11 +1,12 @@
 import { pdf } from '@react-pdf/renderer'
 import JsZip from 'jszip'
 import pLimit from 'p-limit'
-import type { Member, PioneerEnrolment, PublisherActivity } from '~/database/generated/client'
+import type { Member, PublisherActivity } from '~/database/generated/client'
+import { ENROLMENT_PERIOD_SELECT, type EnrolmentPeriod } from '~/features/publishers/model/pioneer-enrolment'
 import { PublisherActivityDocument } from '~/features/publishers/ui/PublisherActivityDocument'
 import type { TransactionClient } from '~/shared/infra/db.server'
 
-type PublisherWithActivities = Member & { activities: PublisherActivity[]; pioneerEnrolments: PioneerEnrolment[] }
+type PublisherWithActivities = Member & { activities: PublisherActivity[]; pioneerEnrolments: EnrolmentPeriod[] }
 
 export interface PublisherScopeOptions {
   groupId?: number
@@ -35,8 +36,8 @@ export async function getPublishersWithYearActivities(
     include: {
       activities: { where: yearFilter },
       // The S-21 sheet ticks a pioneer box from the member's standing status, which lives on the
-      // stints — without these every sheet would print unticked.
-      pioneerEnrolments: true,
+      // stints — without these every sheet would print unticked. Only the period fields are read.
+      pioneerEnrolments: { select: ENROLMENT_PERIOD_SELECT },
     },
   })
 }
diff --git a/app/features/publishers/ui/PublisherActivityDocument.tsx b/app/features/publishers/ui/PublisherActivityDocument.tsx
index 852de8b2..7ac48611 100644
--- a/app/features/publishers/ui/PublisherActivityDocument.tsx
+++ b/app/features/publishers/ui/PublisherActivityDocument.tsx
@@ -1,11 +1,11 @@
 import { Document, Page, Polygon, StyleSheet, Svg, Text, View } from '@react-pdf/renderer'
-import type { Member, PioneerEnrolment, PublisherActivity } from '~/database/generated/client'
-import { standingTypeFromEnrolments } from '~/features/publishers/model/pioneer-enrolment'
+import type { Member, PublisherActivity } from '~/database/generated/client'
+import { type EnrolmentPeriod, standingTypeFromEnrolments } from '~/features/publishers/model/pioneer-enrolment'
 import * as m from '~/i18n/paraglide/messages'
 import { PublisherType } from '~/shared/types/publisher-type'
 
 interface PublisherActivityDocumentProps {
-  publisher: Member & { activities: PublisherActivity[]; pioneerEnrolments: PioneerEnrolment[] }
+  publisher: Member & { activities: PublisherActivity[]; pioneerEnrolments: EnrolmentPeriod[] }
 }
 
 export function PublisherActivityDocument({ publisher }: PublisherActivityDocumentProps) {
diff --git a/app/features/settings/routes/congregation/settings.tsx b/app/features/settings/routes/congregation/settings.tsx
index 4a68add5..a3120106 100644
--- a/app/features/settings/routes/congregation/settings.tsx
+++ b/app/features/settings/routes/congregation/settings.tsx
@@ -22,6 +22,7 @@ import { Label } from '~/shared/ui/label'
 import { PageHeader } from '~/shared/ui/PageHeader'
 import { SubmitButton } from '~/shared/ui/SubmitButton'
 import { UnsavedChangesDialog } from '~/shared/ui/UnsavedChangesDialog'
+import { zonedNow } from '~/shared/utils/zoned-now'
 import type { Route } from './+types/settings'
 
 export const meta: Route.MetaFunction = () => {
@@ -168,9 +169,13 @@ export async function action({ request, context }: Route.ActionArgs) {
     submission.value
 
   return withScopeFromContext(context, async db => {
-    await updateCongregationSettings(db, congregation.id, actorId, {
-      auxiliaryPioneerProfileActivated,
-    })
+    await updateCongregationSettings(
+      db,
+      congregation.id,
+      actorId,
+      { auxiliaryPioneerProfileActivated },
+      zonedNow(congregation.timezone),
+    )
 
     return redirect('/settings/congregation')
   })
diff --git a/app/features/settings/server/congregation-settings.server.test.ts b/app/features/settings/server/congregation-settings.server.test.ts
index 2192ef72..35529703 100644
--- a/app/features/settings/server/congregation-settings.server.test.ts
+++ b/app/features/settings/server/congregation-settings.server.test.ts
@@ -32,13 +32,14 @@ beforeEach(() => {
   mockDb.member.findMany.mockResolvedValue([])
 })
 
+// A fixed instant so the asserted close month is the caller's, not whatever today happens to be.
+const NOW = new Date(2026, 2, 15)
+
 describe('updateCongregationSettings', () => {
   it('sets the auxiliary pioneer setting', async () => {
     vi.mocked(setSetting).mockResolvedValue(undefined as never)
 
-    await updateCongregationSettings(mockDb as never, 10, 99, {
-      auxiliaryPioneerProfileActivated: 'true',
-    })
+    await updateCongregationSettings(mockDb as never, 10, 99, { auxiliaryPioneerProfileActivated: 'true' }, NOW)
 
     expect(setSetting).toHaveBeenCalledWith(mockDb, 'auxiliary-pioneer-profile-active', 'true', 10)
     expect(endOngoingEnrolmentsOfType).not.toHaveBeenCalled()
@@ -52,16 +53,15 @@ describe('updateCongregationSettings', () => {
   it('closes ongoing auxiliary enrolments when the profile is deactivated', async () => {
     vi.mocked(setSetting).mockResolvedValue(undefined as never)
 
-    await updateCongregationSettings(mockDb as never, 10, 99, {
-      auxiliaryPioneerProfileActivated: 'false',
-    })
+    await updateCongregationSettings(mockDb as never, 10, 99, { auxiliaryPioneerProfileActivated: 'false' }, NOW)
 
     expect(endOngoingEnrolmentsOfType).toHaveBeenCalledWith(
       mockDb,
       10,
       99,
       PublisherType.PionnierAuxiliaires,
-      expect.objectContaining({ endMonth: expect.any(Number), endYear: expect.any(Number) }),
+      // Derived from the caller's clock, not the server's: March 2026 is month 2, 0-indexed.
+      { endMonth: 2, endYear: 2026 },
     )
   })
 })
diff --git a/app/features/settings/server/congregation-settings.server.ts b/app/features/settings/server/congregation-settings.server.ts
index 4b0fb8eb..9f89ff04 100644
--- a/app/features/settings/server/congregation-settings.server.ts
+++ b/app/features/settings/server/congregation-settings.server.ts
@@ -12,6 +12,9 @@ export async function updateCongregationSettings(
   data: {
     auxiliaryPioneerProfileActivated: string
   },
+  // The congregation's own clock, not the server's. Closing a stint picks a MONTH, so a server an
+  // hour either side of midnight on the 1st would otherwise date it to the wrong one.
+  now: Date,
 ) {
   await setSetting(
     db,
@@ -24,7 +27,6 @@ export async function updateCongregationSettings(
     // Turning the profile off means these members stop being permanent auxiliaries. That fact lives
     // on the stint now, so close the ongoing ones at the current month rather than flipping a cached
     // column — closing keeps the history of what they actually did.
-    const now = new Date()
     await endOngoingEnrolmentsOfType(db, congregationId, actorId, PublisherType.PionnierAuxiliaires, {
       endMonth: now.getMonth(),
       endYear: now.getFullYear(),