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/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/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/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/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..78ca60fa 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,18 +75,23 @@ 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 () => {
+  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 }),
     )
-    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)
   })
 
-  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, {
@@ -94,12 +100,11 @@ 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)
   })
 
-  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, {
@@ -111,28 +116,24 @@ 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).
+    // 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 }),
     )
-    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,28 +153,25 @@ 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 () => {
+  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 }),
     )
-    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)
   })
 
-  // 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, {
@@ -193,12 +191,11 @@ 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)
   })
 
-  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, {
@@ -215,12 +212,11 @@ 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)
   })
 
-  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, {
@@ -238,7 +234,129 @@ 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)
+  })
+
+  // 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 cf12ac9a..9c4f4cb8 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,14 +50,14 @@ 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
 }
 
 // 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,
@@ -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,43 @@ 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<{ 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, 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)
+  }
+  // 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 { 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 c5ebdbf6..5a097fff 100644
--- a/app/features/publishers/server/publishers.server.test.ts
+++ b/app/features/publishers/server/publishers.server.test.ts
@@ -96,10 +96,12 @@ 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({ type: PublisherType.PionnierPermanant })
+    expect(where).toMatchObject({
+      pioneerEnrolments: { some: { type: PublisherType.PionnierPermanant, endMonth: null } },
+    })
   })
 
   it('combines search, group and type filters', async () => {
@@ -107,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
@@ -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..3be3ad54 100644
--- a/app/features/publishers/server/publishers.server.ts
+++ b/app/features/publishers/server/publishers.server.ts
@@ -1,7 +1,10 @@
 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'
+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.
 export function getPublisherById(
   db: TransactionClient,
   publisherId: MemberId,
@@ -15,6 +18,7 @@ export function getPublisherById(
     include: {
       account: { select: { id: true, email: true, active: true } },
       publisherGroup: { include: { responsible: true, deputy: true } },
+      pioneerEnrolments: { select: ENROLMENT_PERIOD_SELECT },
       activities: {
         where: {
           OR: [
@@ -46,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
     ? {
@@ -60,7 +64,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?.standingType
+    ? {}
+    : options.standingType === PublisherType.Normal
+      ? { pioneerEnrolments: { none: { 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 6d5db080..5f8fa581 100644
--- a/app/features/publishers/server/render-activity-pdf-zip.server.tsx
+++ b/app/features/publishers/server/render-activity-pdf-zip.server.tsx
@@ -2,10 +2,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 { 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[] }
+type PublisherWithActivities = Member & { activities: PublisherActivity[]; pioneerEnrolments: EnrolmentPeriod[] }
 
 export interface PublisherScopeOptions {
   groupId?: number
@@ -34,6 +35,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. Only the period fields are read.
+      pioneerEnrolments: { select: ENROLMENT_PERIOD_SELECT },
     },
   })
 }
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..7ac48611 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 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[] }
+  publisher: Member & { activities: PublisherActivity[]; pioneerEnrolments: EnrolmentPeriod[] }
 }
 
 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/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/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..35529703 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: {
@@ -32,71 +32,36 @@ 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(mockDb.member.updateMany).not.toHaveBeenCalled()
-    expect(syncBuiltInRoleAssignments).not.toHaveBeenCalled()
-  })
-
-  it('resets auxiliary pioneers to normal when feature 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)
+    expect(endOngoingEnrolmentsOfType).not.toHaveBeenCalled()
   })
 
-  it('does not sync when no auxiliary pioneers exist to reset', 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.findMany.mockResolvedValue([])
-    mockDb.member.updateMany.mockResolvedValue({ count: 0 })
 
-    await updateCongregationSettings(mockDb as never, 10, 99, {
-      auxiliaryPioneerProfileActivated: 'false',
-    })
+    await updateCongregationSettings(mockDb as never, 10, 99, { auxiliaryPioneerProfileActivated: 'false' }, NOW)
 
-    expect(mockDb.member.updateMany).toHaveBeenCalled()
-    expect(syncBuiltInRoleAssignments).not.toHaveBeenCalled()
+    expect(endOngoingEnrolmentsOfType).toHaveBeenCalledWith(
+      mockDb,
+      10,
+      99,
+      PublisherType.PionnierAuxiliaires,
+      // 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 33fe372a..9f89ff04 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'
@@ -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,
@@ -21,13 +24,13 @@ 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.
+    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,
       },