diff --git a/apps/edr-passenger-api/prisma/migrations/20260724000001_add_booking_pay_token/migration.sql b/apps/edr-passenger-api/prisma/migrations/20260724000001_add_booking_pay_token/migration.sql
new file mode 100644
index 000000000..89bb4b50a
--- /dev/null
+++ b/apps/edr-passenger-api/prisma/migrations/20260724000001_add_booking_pay_token/migration.sql
@@ -0,0 +1,10 @@
+-- Adds Booking.payToken/payTokenExpiresAt: an opaque, expiring token used by the
+-- reserve-seat "issue booking (passenger)" flow to let a traveler pay via an SMS'd
+-- link without needing a portal session (see GuestBookingService.issueBookingFromReservation
+-- and BookingsService.getByPayToken). Nullable — only set for reservation-issued bookings
+-- awaiting passenger payment; a normal guest/portal booking never sets it.
+
+ALTER TABLE "passenger"."Booking" ADD COLUMN IF NOT EXISTS "payToken" TEXT;
+ALTER TABLE "passenger"."Booking" ADD COLUMN IF NOT EXISTS "payTokenExpiresAt" TIMESTAMP(3);
+
+CREATE UNIQUE INDEX IF NOT EXISTS "Booking_payToken_key" ON "passenger"."Booking"("payToken");
diff --git a/apps/edr-passenger-api/prisma/schema.prisma b/apps/edr-passenger-api/prisma/schema.prisma
index de086e465..467bff071 100644
--- a/apps/edr-passenger-api/prisma/schema.prisma
+++ b/apps/edr-passenger-api/prisma/schema.prisma
@@ -550,6 +550,8 @@ model Booking {
   paidAt                    DateTime?
   paymentReminderSentAt     DateTime?
   packageDepartureStationId String?
+  payToken                  String?               @unique
+  payTokenExpiresAt         DateTime?
   createdAt                 DateTime              @default(now())
   updatedAt                 DateTime              @updatedAt
   passenger                 Passenger             @relation(fields: [passengerId], references: [id])
diff --git a/apps/edr-passenger-api/src/modules/bookings/bookings.controller.ts b/apps/edr-passenger-api/src/modules/bookings/bookings.controller.ts
index 88bbe6ec4..5953d17a2 100644
--- a/apps/edr-passenger-api/src/modules/bookings/bookings.controller.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/bookings.controller.ts
@@ -32,9 +32,11 @@ import {
 import {
   CreateGuestBookingDto,
   GetSavedPassengersDto,
+  IssueReservationBookingDto,
 } from "./guest-booking.dto";
 import { JwtGuard } from "../../common/jwt.guard";
-import { PassengerAdmin } from "../../common/passenger-guards";
+import { PassengerAdmin, PassengerStaff } from "../../common/passenger-guards";
+import { PASSENGER_PERMS } from "../../seed/passenger-permissions.registry";
 
 @ApiTags("Booking")
 @Controller("bookings")
@@ -349,6 +351,35 @@ export class BookingsController {
     return this.guestService.createGuestBooking(dto, req);
   }
 
+  @Post("reservations/:seatId/issue")
+  @PassengerStaff([PASSENGER_PERMS.seats.manage, PASSENGER_PERMS.bookings.manage, PASSENGER_PERMS.admin])
+  @ApiBearerAuth("IAM-auth")
+  @ApiOperation({
+    summary: "Issue a booking from a reserved (blocked) seat",
+    description:
+      "Converts an admin-reserved seat into a real booking for one traveler. bookingKind STAFF waives the fee and issues the ticket immediately; bookingKind PASSENGER creates the booking as PENDING_PAYMENT and texts a payment link to the traveler's phone.",
+  })
+  @ApiBody({ type: IssueReservationBookingDto })
+  issueBookingFromReservation(
+    @Param("seatId") seatId: string,
+    @Body() dto: IssueReservationBookingDto,
+    @Req() req: any,
+  ) {
+    const actingUserId = req.user?.id ?? req.user?.sub ?? null;
+    return this.guestService.issueBookingFromReservation(seatId, dto, actingUserId);
+  }
+
+  @Get("pay/:token")
+  @SetMetadata("isPublic", true)
+  @ApiOperation({
+    summary: "Resolve a reservation booking by its pay token (public)",
+    description:
+      "Used by the portal's standalone pay-by-link page for a reservation booking awaiting passenger payment — no login required.",
+  })
+  getByPayToken(@Param("token") token: string) {
+    return this.service.getByPayToken(token);
+  }
+
   @Get("saved-passengers")
   @SetMetadata("isPublic", true)
   @ApiOperation({
diff --git a/apps/edr-passenger-api/src/modules/bookings/bookings.module.ts b/apps/edr-passenger-api/src/modules/bookings/bookings.module.ts
index 0ce77ad5b..78b7d4bc7 100644
--- a/apps/edr-passenger-api/src/modules/bookings/bookings.module.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/bookings.module.ts
@@ -10,9 +10,11 @@ import { CurrencyModule } from '../currency/currency.module';
 import { AuthModule } from '../auth/auth.module';
 import { FareEngineModule } from '../fare-engine/fare-engine.module';
 import { TicketsModule } from '../tickets/tickets.module';
+import { PaymentsModule } from '../payments/payments.module';
+import { NotificationsModule } from '../notifications/notifications.module';
 
 @Module({
-  imports: [AuditModule, SeatsModule, VerifaydaModule, CurrencyModule, FareEngineModule, HttpModule, AuthModule, TicketsModule],
+  imports: [AuditModule, SeatsModule, VerifaydaModule, CurrencyModule, FareEngineModule, HttpModule, AuthModule, TicketsModule, PaymentsModule, NotificationsModule],
   controllers: [BookingsController],
   providers: [BookingsService, GuestBookingService],
   exports: [BookingsService, GuestBookingService]
diff --git a/apps/edr-passenger-api/src/modules/bookings/bookings.service.ts b/apps/edr-passenger-api/src/modules/bookings/bookings.service.ts
index 98a54528b..b5825ddc5 100644
--- a/apps/edr-passenger-api/src/modules/bookings/bookings.service.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/bookings.service.ts
@@ -1860,6 +1860,52 @@ export class BookingsService {
     );
   }
 
+  /**
+   * Resolves a reservation booking by its standalone payToken — the public entry point for
+   * the portal's pay-by-link page (a traveler who never had a portal session, texted a link
+   * by a reservation-issuing staff member). Payment itself still goes through the already-
+   * public /payments/* endpoints (initiate/methods/booking-amount/status), keyed by the
+   * booking id this returns — no change needed there.
+   */
+  async getByPayToken(token: string) {
+    const booking = await this.prisma.booking.findUnique({
+      where: { payToken: token },
+      include: {
+        schedule: { include: { originStation: true, destinationStation: true, train: true, stopTimes: { include: { station: true } } } },
+        seats: { include: { seat: { include: { coach: true } } } },
+      },
+    });
+    if (!booking) throw new NotFoundException('Payment link not found');
+    if (booking.status !== 'PENDING_PAYMENT') throw new BadRequestException('This booking is no longer awaiting payment');
+    if ((booking as any).payTokenExpiresAt && (booking as any).payTokenExpiresAt < new Date()) {
+      throw new BadRequestException('This payment link has expired');
+    }
+
+    const segment = resolveBookingSegment((booking as any).schedule, (booking as any).originStationId, (booking as any).destinationStationId);
+    return {
+      id: booking.id,
+      bookingRef: booking.bookingRef,
+      status: booking.status,
+      totalMinor: booking.totalMinor,
+      currency: booking.currency,
+      displayCurrency: booking.displayCurrency,
+      displayTotalMinor: booking.displayTotalMinor,
+      schedule: {
+        trainNumber: (booking as any).schedule.train.number,
+        trainName: (booking as any).schedule.train.name,
+        origin: { id: segment.origin.id, name: segment.origin.name, code: segment.origin.code },
+        destination: { id: segment.destination.id, name: segment.destination.name, code: segment.destination.code },
+        departureAt: segment.departureAt,
+        arrivalAt: segment.arrivalAt,
+      },
+      seats: (booking as any).seats.map((s: any) => ({
+        passengerName: s.passengerName,
+        seatNumber: s.seat?.seatNumber ?? null,
+        coach: s.seat?.coach?.number ?? null,
+      })),
+    };
+  }
+
   async getByRef(bookingRefOrId: string) {
     const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(bookingRefOrId);
     const booking = await this.prisma.booking.findUnique({
diff --git a/apps/edr-passenger-api/src/modules/bookings/guest-booking.dto.ts b/apps/edr-passenger-api/src/modules/bookings/guest-booking.dto.ts
index f89b5228d..ac60b8480 100644
--- a/apps/edr-passenger-api/src/modules/bookings/guest-booking.dto.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/guest-booking.dto.ts
@@ -1,4 +1,4 @@
-import { IsString, IsArray, ValidateNested, IsOptional, IsEnum, IsDateString, IsBoolean, IsInt, IsNumber } from 'class-validator';
+import { IsString, IsArray, ValidateNested, IsOptional, IsEnum, IsDateString, IsBoolean, IsInt, IsNumber, IsIn } from 'class-validator';
 import { Type } from 'class-transformer';
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 import { Currency, IdDocumentType } from '@prisma/client';
@@ -174,6 +174,67 @@ export class SavedPassengerProfileDto {
 }
 
 export class GetSavedPassengersDto {
-  @ApiPropertyOptional({ example: 'device-uuid-12345', description: 'Device ID to retrieve saved passengers' }) 
+  @ApiPropertyOptional({ example: 'device-uuid-12345', description: 'Device ID to retrieve saved passengers' })
   @IsOptional() @IsString() deviceId?: string;
 }
+
+export enum ReservationBookingKind {
+  STAFF = 'STAFF',
+  PASSENGER = 'PASSENGER',
+}
+
+export const RESERVATION_NATIONALITIES = ['Ethiopian', 'Djiboutian', 'Other'] as const;
+export type ReservationNationality = (typeof RESERVATION_NATIONALITIES)[number];
+
+/**
+ * Issues a real booking against a seat an admin/staff previously reserved (SeatBlock) —
+ * one traveler per seat, fare always server-computed (no seatFareMinor/reviewedTotalMinor
+ * override: unlike the guest DTO, there's no untrusted client-displayed price to defend
+ * against here). seatId comes from the route param, not the body.
+ *
+ * No seatClassId — the seat (and therefore its coach/class) is already fixed by the
+ * reservation being converted; the service resolves the correct seat class itself from the
+ * seat's own coach type and nationality (LOCAL vs INTERNATIONAL pricing tier), the same
+ * matching search results already use. No passportCountry — nationality alone is what
+ * drives both fare-tier selection and passport-vs-national-ID validation.
+ */
+export class IssueReservationBookingDto {
+  @ApiProperty({ example: 'schedule-uuid' })
+  @IsString() scheduleId: string;
+
+  @ApiProperty({ example: 'station-uuid' })
+  @IsString() originStationId: string;
+
+  @ApiProperty({ example: 'station-uuid' })
+  @IsString() destinationStationId: string;
+
+  @ApiProperty({ enum: ReservationBookingKind, description: 'STAFF: no fee, ticket issued immediately. PASSENGER: a payment link is sent to phone.' })
+  @IsEnum(ReservationBookingKind) bookingKind: ReservationBookingKind;
+
+  @ApiProperty({ example: 'Abebe Kebede' })
+  @IsString() passengerName: string;
+
+  @ApiProperty({ example: '1990-05-15', description: 'Date of birth (YYYY-MM-DD) for age calculation' })
+  @IsDateString() dateOfBirth: string;
+
+  @ApiProperty({ example: 'NATIONAL_ID', enum: IdDocumentType })
+  @IsEnum(IdDocumentType) idDocumentType: IdDocumentType;
+
+  @ApiPropertyOptional({ example: 'ET123456789' })
+  @IsOptional() @IsString() idDocumentNumber?: string;
+
+  @ApiPropertyOptional({ example: 'P1234567' })
+  @IsOptional() @IsString() passportNumber?: string;
+
+  @ApiProperty({ example: 'Ethiopian', enum: RESERVATION_NATIONALITIES, description: 'Drives both the LOCAL/INTERNATIONAL fare tier and passport-vs-national-ID validation.' })
+  @IsIn(RESERVATION_NATIONALITIES) nationality: ReservationNationality;
+
+  @ApiPropertyOptional({ example: '+251912345678', description: 'Required when bookingKind is PASSENGER — the payment link is sent here.' })
+  @IsOptional() @IsString() phone?: string;
+
+  @ApiPropertyOptional({ example: 'abebe@email.com' })
+  @IsOptional() @IsString() email?: string;
+
+  @ApiPropertyOptional({ example: 'ETB', enum: Currency })
+  @IsOptional() @IsEnum(Currency) displayCurrency?: Currency;
+}
diff --git a/apps/edr-passenger-api/src/modules/bookings/guest-booking.service.ts b/apps/edr-passenger-api/src/modules/bookings/guest-booking.service.ts
index 3e2a225e6..0e27eb989 100644
--- a/apps/edr-passenger-api/src/modules/bookings/guest-booking.service.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/guest-booking.service.ts
@@ -6,9 +6,14 @@ import { CurrencyService } from '../currency/currency.service';
 import { PassengerAuthService } from '../auth/passenger-auth.service';
 import { FareEngineService } from '../fare-engine/fare-engine.service';
 import { EventEmitter2 } from '@nestjs/event-emitter';
-import { CreateGuestBookingDto, SavedPassengerProfileDto } from './guest-booking.dto';
-import { Currency, PassengerCategory, IdDocumentType } from '@prisma/client';
+import { PaymentsService } from '../payments/payments.service';
+import { AuditService } from '../../common/audit.service';
+import { SmsClientService } from '../notifications/sms-client.service';
+import { CreateGuestBookingDto, SavedPassengerProfileDto, IssueReservationBookingDto, ReservationBookingKind } from './guest-booking.dto';
+import { Currency, PassengerCategory, IdDocumentType, PaymentMethodType, PaymentIntentStatus } from '@prisma/client';
 import { resolveCheckinCutoff } from '../../common/utils/checkin-cutoff.utils';
+import { computePaymentDeadline } from '../../common/utils/payment-deadline.utils';
+import { randomUUID } from 'crypto';
 
 /**
  * Throws if the given boarding stop's own configurable check-in cutoff (route/stop
@@ -25,6 +30,29 @@ function assertWithinCheckinCutoff(schedule: any, stopTime: any, stationId: stri
   }
 }
 
+/**
+ * Resolves the seat class for a specific, already-known seat (its coach type only ever
+ * offers a fixed set of classes) given the traveler's nationality tier — mirrors
+ * search.service.ts's own LOCAL/INTERNATIONAL + bed-position matching so the price a
+ * reservation-issued booking charges is the exact same "already configured price setup"
+ * search results would have quoted, without asking the admin to redundantly re-pick a class
+ * for a seat whose class is already fixed.
+ */
+function resolveSeatClassForSeat(seat: any, nationality: string): { id: string; name: string } {
+  const nationalityUpper = (nationality ?? '').toUpperCase();
+  const resolvedNationalityType = nationalityUpper === 'ETHIOPIAN' || nationalityUpper === 'DJIBOUTIAN' ? 'LOCAL' : 'INTERNATIONAL';
+  const candidates = (seat.coach?.coachType?.seatClasses ?? []).filter(
+    (sc: any) => !sc.nationalityType || sc.nationalityType === resolvedNationalityType,
+  );
+  const matchingClass = seat.bedPosition
+    ? candidates.find((sc: any) => sc.bedPosition?.toLowerCase() === seat.bedPosition)
+    : candidates[0];
+  if (!matchingClass) {
+    throw new BadRequestException('No seat class is configured for this seat and nationality — set up seat classes for this coach type first.');
+  }
+  return matchingClass;
+}
+
 function generateRef(): string {
   const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
   return Array.from({ length: 6 }, () => chars[Math.floor(Math.random() * chars.length)]).join('');
@@ -65,6 +93,9 @@ export class GuestBookingService {
     private passengerAuthService: PassengerAuthService,
     private fareEngine: FareEngineService,
     private eventEmitter: EventEmitter2,
+    private paymentsService: PaymentsService,
+    private auditService: AuditService,
+    private smsClient: SmsClientService,
   ) { }
 
   /**
@@ -384,6 +415,228 @@ export class GuestBookingService {
     };
   }
 
+  /**
+   * Converts an admin-reserved seat (SeatBlock) into a real booking for one traveler —
+   * no SeatHold involved (the seat was already set aside), so this mirrors
+   * createGuestOneWayBooking's schedule/fare/passenger resolution but skips the hold check
+   * and instead validates+releases the SeatBlock. STAFF bookings are fee-waived and
+   * finalized immediately via the same PaymentsService.finalizePaymentSuccess() path every
+   * real payment webhook uses; PASSENGER bookings are left PENDING_PAYMENT with a payToken
+   * texted to the traveler so they can pay via the existing, already-public /payments/*
+   * endpoints without a portal session.
+   */
+  async issueBookingFromReservation(
+    seatId: string,
+    dto: IssueReservationBookingDto,
+    actingUserId: string | null,
+  ): Promise<{ booking: any; payUrl?: string }> {
+    if (dto.bookingKind === ReservationBookingKind.PASSENGER && !dto.phone) {
+      throw new BadRequestException('Phone number is required for a passenger booking');
+    }
+    if (dto.idDocumentType === IdDocumentType.NATIONAL_ID && dto.nationality !== 'Ethiopian') {
+      throw new BadRequestException('National ID is only valid for Ethiopian nationality — use a passport instead');
+    }
+
+    const seatBlock = await this.prisma.seatBlock.findFirst({
+      where: { seatId, OR: [{ scheduleId: dto.scheduleId }, { scheduleId: null }] },
+    });
+    if (!seatBlock) throw new NotFoundException('Seat is not reserved');
+
+    // The seat (and therefore its coach) is already fixed by the reservation — resolve the
+    // seat class from the seat's own coach type + the traveler's nationality tier, the same
+    // LOCAL/INTERNATIONAL + bed-position matching search results already use, instead of
+    // asking the admin to redundantly pick a class.
+    const seat = await this.prisma.seat.findUnique({
+      where: { id: seatId },
+      include: { coach: { include: { coachType: { include: { seatClasses: true } } } } },
+    });
+    if (!seat) throw new NotFoundException('Seat not found');
+    const resolvedSeatClass = resolveSeatClassForSeat(seat, dto.nationality);
+
+    const schedule = await this.prisma.trainSchedule.findUnique({
+      where: { id: dto.scheduleId },
+      include: {
+        originStation: true,
+        destinationStation: true,
+        stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } },
+        route: { include: { stops: true } },
+      },
+    });
+    if (!schedule) throw new NotFoundException('Schedule not found');
+
+    const originStop = schedule.stopTimes.find(s => s.stationId === dto.originStationId)
+      ?? (schedule.stopTimes.length === 0 ? { stationId: schedule.originStationId, sequence: 0, station: schedule.originStation } : undefined);
+    const destStop = schedule.stopTimes.find(s => s.stationId === dto.destinationStationId)
+      ?? (schedule.stopTimes.length === 0 ? { stationId: schedule.destinationStationId, sequence: 1, station: schedule.destinationStation } : undefined);
+    if (!originStop || !destStop) throw new NotFoundException('Origin or destination not found');
+
+    assertWithinCheckinCutoff(schedule, originStop, dto.originStationId);
+
+    const segmentRoute = `${originStop.station.code}-${destStop.station.code}`;
+    const fullRoute = `${schedule.originStation.code}-${schedule.destinationStation.code}`;
+
+    // Single-traveler passenger processing. nationality is a fixed dropdown value (Ethiopian/
+    // Djiboutian/Other), so — unlike the guest-booking loop this mirrors — there's no need to
+    // infer it from document type/country; only the Verifayda check (NATIONAL_ID) and the
+    // passport-number requirement (PASSPORT) still depend on the chosen document type.
+    const dateOfBirth = new Date(dto.dateOfBirth);
+    const age = calculateAge(dateOfBirth);
+    const category: PassengerCategory = age < 5 ? PassengerCategory.CHILD : PassengerCategory.ADULT;
+
+    let passengerName = dto.passengerName;
+    let verifaydaVerified = false;
+    let verifaydaData: Record<string, any> | undefined;
+
+    if (dto.idDocumentType === IdDocumentType.NATIONAL_ID) {
+      if (dto.idDocumentNumber) {
+        const verification = await this.verifaydaService.verifyNationalId(dto.idDocumentNumber);
+        if (!verification.verified) {
+          throw new BadRequestException(`Verifayda verification failed for ${dto.passengerName}: ${verification.failureReason}`);
+        }
+        passengerName = verification.passengerData?.fullName || passengerName;
+        verifaydaVerified = true;
+        verifaydaData = verification.passengerData?.profileData;
+      }
+    } else if (dto.idDocumentType === IdDocumentType.PASSPORT) {
+      if (!dto.passportNumber) {
+        throw new BadRequestException(`Passport number required for ${dto.passengerName}`);
+      }
+    }
+
+    const passengerData = {
+      passengerName,
+      dateOfBirth,
+      category,
+      verifaydaVerified,
+      verifaydaData,
+      nationality: dto.nationality,
+      idDocumentType: dto.idDocumentType,
+      idDocumentNumber: dto.idDocumentNumber,
+      passportNumber: dto.passportNumber,
+      phone: dto.phone,
+      email: dto.email,
+    };
+
+    const baseFareMinor = await this.getBaseFare(
+      dto.scheduleId,
+      resolvedSeatClass.id,
+      segmentRoute,
+      fullRoute,
+      dto.nationality,
+      dto.originStationId,
+      dto.destinationStationId,
+    );
+
+    const isStaff = dto.bookingKind === ReservationBookingKind.STAFF;
+    const displayCurrency = dto.displayCurrency || Currency.ETB;
+    const totalMinor = isStaff ? 0 : baseFareMinor;
+    if (!isStaff) {
+      // Defense-in-depth — there's no client-forgeable price on this DTO, but keep the
+      // same authoritative-fare floor every other booking path enforces.
+      this.assertTotalNotUnderAuthoritative(totalMinor, baseFareMinor, 'issueBookingFromReservation');
+    }
+    const displayTotalMinor = displayCurrency !== Currency.ETB
+      ? await this.currencyService.convertAmount(totalMinor, Currency.ETB, displayCurrency)
+      : totalMinor;
+
+    const { guestPassengerId } = await this.resolveGuestPassenger({}, passengerData);
+
+    const payToken = isStaff ? undefined : randomUUID();
+    const payTokenExpiresAt = isStaff ? undefined : computePaymentDeadline(new Date(), schedule.departureAt);
+
+    const booking = await this.prisma.booking.create({
+      data: {
+        bookingRef: generateRef(),
+        passengerId: guestPassengerId,
+        scheduleId: dto.scheduleId,
+        originStationId: dto.originStationId,
+        destinationStationId: dto.destinationStationId,
+        status: 'PENDING_PAYMENT',
+        totalMinor,
+        currency: Currency.ETB,
+        adultCount: category === PassengerCategory.ADULT ? 1 : 0,
+        childCount: category === PassengerCategory.CHILD ? 1 : 0,
+        displayCurrency,
+        displayTotalMinor,
+        bookingType: 'ONE_WAY',
+        source: 'BACKOFFICE_RESERVATION',
+        contactEmail: dto.email || null,
+        contactPhone: dto.phone || null,
+        payToken,
+        payTokenExpiresAt,
+        seats: {
+          create: [{
+            seat: { connect: { id: seatId } },
+            scheduleId: dto.scheduleId,
+            passengerName: passengerData.passengerName,
+            dateOfBirth: passengerData.dateOfBirth,
+            passengerCategory: passengerData.category,
+            idDocumentType: passengerData.idDocumentType,
+            passportNumber: passengerData.passportNumber,
+            verifaydaVerified: passengerData.verifaydaVerified,
+            verifaydaData: passengerData.verifaydaData || undefined,
+            fareMinor: totalMinor,
+            displayCurrency,
+          }],
+        },
+      },
+      include: {
+        seats: { include: { seat: { include: { coach: true } } } },
+        schedule: { include: { originStation: true, destinationStation: true, train: true } },
+      },
+    });
+
+    await this.createTravelerProfiles(guestPassengerId, [passengerData]);
+
+    // Release the reservation using the SAME scope it was created with (global vs
+    // schedule-scoped) — unblockSeat already correctly resets Seat.status for a global
+    // block; reimplementing that here would risk missing that reset.
+    await this.seatsService.unblockSeat(seatId, seatBlock.scheduleId ?? undefined);
+    await this.seatsService.confirmSeats([seatId]);
+    this.eventEmitter.emit('booking.created', { booking });
+
+    if (isStaff) {
+      await this.auditService.log({
+        userId: actingUserId ?? undefined,
+        action: 'CREATE',
+        entityType: 'Booking',
+        entityId: booking.id,
+        newData: { feeWaived: true, waivedBy: actingUserId, originalFareMinor: baseFareMinor },
+      });
+
+      const intent = await this.prisma.paymentIntent.create({
+        data: {
+          bookingId: booking.id,
+          amountMinor: 0,
+          currency: 'ETB',
+          // WALLET is an internal-only method that never leaves this app (see
+          // payments.service.ts) — safe, inert placeholder for a zero-charge waiver.
+          method: PaymentMethodType.WALLET,
+          status: PaymentIntentStatus.REQUIRES_ACTION,
+        },
+      });
+      await this.paymentsService.finalizePaymentSuccess({ intentId: intent.id });
+      // finalizePaymentSuccess mutates the booking (status -> CONFIRMED) in the DB —
+      // re-fetch so the caller sees the actual outcome, not the pre-finalization snapshot.
+      const confirmedBooking = await this.prisma.booking.findUnique({ where: { id: booking.id } });
+      return { booking: confirmedBooking };
+    }
+
+    const portalUrl = process.env.PORTAL_URL ?? 'http://localhost:5174';
+    const payUrl = `${portalUrl}/reserve/pay/${payToken}`;
+    const amountStr = (totalMinor / 100).toFixed(2);
+    try {
+      await this.smsClient.sendSms({
+        to: dto.phone!,
+        message: `EDR: Your seat is reserved. Pay ${amountStr} ETB to confirm your ticket: ${payUrl}`,
+      });
+    } catch (err) {
+      this.logger.warn(`Reservation payment-link SMS failed for booking ${booking.bookingRef}: ${err}`);
+    }
+
+    return { booking, payUrl };
+  }
+
   private async createGuestRoundTripBooking(dto: CreateGuestBookingDto, req?: any) {
     if (!dto.returnScheduleId || !dto.returnHoldId || !dto.returnOriginStationId || !dto.returnDestinationStationId) {
       throw new BadRequestException('returnScheduleId, returnHoldId, returnOriginStationId and returnDestinationStationId are required for ROUND_TRIP');
diff --git a/apps/edr-passenger-api/test/auth-gaps.e2e-spec.ts b/apps/edr-passenger-api/test/auth-gaps.e2e-spec.ts
index b05495296..b02820af4 100644
--- a/apps/edr-passenger-api/test/auth-gaps.e2e-spec.ts
+++ b/apps/edr-passenger-api/test/auth-gaps.e2e-spec.ts
@@ -1,15 +1,12 @@
 /**
  * Auth/authorization gaps (matrix Suite J), via route guard metadata — no boot needed.
  *
- *   C-8 🔴 The exchange-rate write routes (PUT upsert, PATCH update) carry no METHOD-LEVEL guard, so
- *          they get only the global JwtGuard (authentication) and NOT @PassengerAdmin (authorization)
- *          — unlike DELETE, which is admin-gated. Net effect (verified live in
- *          e2e-ui .../pb-config-propagation.spec.ts BC-11): anonymous → 401, but ANY authenticated
- *          user incl. a passenger → 200 rewrites live FX. fare-engine/currency.controller.ts:25,32,42
- *
- * NOTE: this metadata check proves the missing ADMIN guard, NOT "unauthenticated" — a global
- * APP_GUARD=JwtGuard (SharedAuthModule) still requires a valid token. The earlier "unauthenticated
- * FX write" reading was a false positive corrected by the live BC-11 test.
+ *   C-8 ✅ FIXED (was 🔴 "The exchange-rate write routes (PUT upsert, PATCH update) carry no
+ *          METHOD-LEVEL guard, so they get only the global JwtGuard, not @PassengerAdmin —
+ *          unlike DELETE, which was admin-gated. Net effect: any authenticated user incl. a
+ *          passenger could rewrite live FX rates."): currency.controller.ts now decorates
+ *          upsert/update/remove all with @PassengerAdmin() — confirmed by reading the source.
+ *          Updated below to assert all three routes are admin-gated, not just DELETE.
  */
 import "reflect-metadata";
 import { CurrencyController } from "../src/modules/fare-engine/currency.controller";
@@ -20,15 +17,15 @@ function guardsOn(handler: unknown): unknown[] {
 }
 
 describe("Auth gaps (Suite J)", () => {
-  it("C-8 🔴 PUT upsert exchange-rate has NO admin guard (only the global JwtGuard applies)", () => {
-    expect(guardsOn(CurrencyController.prototype.upsert)).toHaveLength(0);
+  it("C-8 ✅ PUT upsert exchange-rate IS admin-gated", () => {
+    expect(guardsOn(CurrencyController.prototype.upsert).length).toBeGreaterThan(0);
   });
 
-  it("C-8 🔴 PATCH update exchange-rate has NO admin guard (only the global JwtGuard applies)", () => {
-    expect(guardsOn(CurrencyController.prototype.update)).toHaveLength(0);
+  it("C-8 ✅ PATCH update exchange-rate IS admin-gated", () => {
+    expect(guardsOn(CurrencyController.prototype.update).length).toBeGreaterThan(0);
   });
 
-  it("C-8 control: DELETE exchange-rate IS admin-gated — proving writes should be too", () => {
+  it("C-8 control: DELETE exchange-rate IS admin-gated too — all three writes consistently guarded", () => {
     expect(guardsOn(CurrencyController.prototype.remove).length).toBeGreaterThan(0);
   });
 });
diff --git a/apps/edr-passenger-api/test/authed-booking-passengerid.e2e-spec.ts b/apps/edr-passenger-api/test/authed-booking-passengerid.e2e-spec.ts
index ff4a59944..3fa50f98d 100644
--- a/apps/edr-passenger-api/test/authed-booking-passengerid.e2e-spec.ts
+++ b/apps/edr-passenger-api/test/authed-booking-passengerid.e2e-spec.ts
@@ -82,6 +82,7 @@ describe("Authenticated booking passengerId resolution (regression)", () => {
       prisma as any,
       { query: async () => [] } as any, // dataSource (resolveIamContact raw SQL → [])
       asyncStub(), // seatsService
+      asyncStub(), // ticketsService — constructor gained this param since this test was written
       { emit: () => true } as any,
       asyncStub(), // verifaydaService (PASSPORT skips)
       asyncStub(), // currencyService (ETB skips)
diff --git a/apps/edr-passenger-api/test/booking-types.e2e-spec.ts b/apps/edr-passenger-api/test/booking-types.e2e-spec.ts
new file mode 100644
index 000000000..105be8a2e
--- /dev/null
+++ b/apps/edr-passenger-api/test/booking-types.e2e-spec.ts
@@ -0,0 +1,365 @@
+/**
+ * Booking-type coverage — ROUND_TRIP, TRANSIT, ROUND_TRIP_TRANSIT end-to-end through
+ * GuestBookingService.createGuestBooking(). ONE_WAY is already covered by
+ * stop-based-booking-segment.e2e-spec.ts / checkin-cutoff.e2e-spec.ts and is not repeated
+ * here.
+ *
+ * TRANSIT/ROUND_TRIP_TRANSIT use seed-core's single A(seq1)->B(seq2)->C(seq3) route for the
+ * outbound/leg2 direction (transit at B). ROUND_TRIP/ROUND_TRIP_TRANSIT additionally need a
+ * genuine return direction — createGuestRoundTripBooking does NOT validate stop-sequence
+ * ordering between origin/destination (confirmed by reading the method), so it would silently
+ * accept a "return" leg on the same forward route, but that's not what a real round trip is.
+ * A local reverse route (C(seq1)->B(seq2)->A(seq3)) is created per-test instead, keeping
+ * seed-core.ts itself untouched (this reverse route isn't a general-purpose fixture need).
+ *
+ * Uses the same harness/Tier-2 pattern as reserve-seat-issue-booking.e2e-spec.ts and
+ * stop-based-booking-segment.e2e-spec.ts.
+ */
+import { IdDocumentType, PassengerCategory } from "@prisma/client";
+import { SchedulesService } from "../src/modules/schedules/schedules.service";
+import { SeatsService } from "../src/modules/seats/seats.service";
+import { CurrencyService } from "../src/modules/currency/currency.service";
+import { FareEngineService } from "../src/modules/fare-engine/fare-engine.service";
+import { SystemConfigService } from "../src/modules/system-config/system-config.service";
+import { GuestBookingService } from "../src/modules/bookings/guest-booking.service";
+import { createServiceHarness, ServiceHarness } from "./setup/slim-app";
+import { IDS, DISTANCE, resetAndSeedCore } from "./fixtures/seed-core";
+
+function asyncStub(): any {
+  return new Proxy({}, { get: () => async () => undefined });
+}
+
+describe("Booking types — ROUND_TRIP / TRANSIT / ROUND_TRIP_TRANSIT", () => {
+  let harness: ServiceHarness;
+  let schedulesService: SchedulesService;
+  let seatsService: SeatsService;
+  let guestBookingService: GuestBookingService;
+  let reverseRouteId: string;
+
+  beforeAll(async () => {
+    harness = await createServiceHarness();
+    schedulesService = await harness.moduleRef.resolve(SchedulesService);
+    const currencyService = harness.moduleRef.get(CurrencyService);
+    const fareEngine = harness.moduleRef.get(FareEngineService);
+    const systemConfig = new SystemConfigService(harness.prisma as any);
+
+    seatsService = new SeatsService(harness.prisma as any, asyncStub(), systemConfig, asyncStub(), asyncStub());
+    guestBookingService = new GuestBookingService(
+      harness.prisma as any,
+      seatsService,
+      asyncStub(), // verifaydaService — test passengers use PASSPORT, not NATIONAL_ID
+      currencyService,
+      asyncStub(), // passengerAuthService — no createAccount in these DTOs
+      fareEngine,
+      { emit: () => true } as any, // eventEmitter
+      asyncStub(), // paymentsService — not reached by createGuestBooking
+      asyncStub(), // auditService
+      asyncStub(), // smsClient
+    );
+  });
+
+  afterAll(async () => {
+    await harness?.close();
+  });
+
+  beforeEach(async () => {
+    await resetAndSeedCore(harness.prisma);
+    reverseRouteId = await createReverseRoute();
+  });
+
+  /** Mirrors seed-core's A->B->C route but reversed (C->B->A), for a genuine return leg. */
+  async function createReverseRoute(): Promise<string> {
+    const route = await harness.prisma.route.create({
+      data: {
+        code: `RT-REV-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
+        name: "Reverse Line",
+        effectiveFrom: new Date("2020-01-01T00:00:00.000Z"),
+        active: true,
+        stops: {
+          create: [
+            { stationId: IDS.stationC, sequence: 1, distanceKm: 0 },
+            { stationId: IDS.stationB, sequence: 2, distanceKm: DISTANCE.C - DISTANCE.B },
+            { stationId: IDS.stationA, sequence: 3, distanceKm: DISTANCE.C - DISTANCE.A },
+          ],
+        },
+      },
+    });
+    return route.id;
+  }
+
+  /** Coach assigned via coachIds at creation time — createSchedule rejects zero coaches. */
+  async function createTestSchedule(opts: { trainNumber: string; routeId: string; departureAt: Date; arrivalAt: Date }) {
+    const train = await harness.prisma.train.create({
+      data: { number: opts.trainNumber, name: `Test ${opts.trainNumber}` },
+    });
+    const coach = await harness.prisma.coach.create({
+      data: { coachTypeId: IDS.coachType, number: `${opts.trainNumber}-C1`, capacity: 6, sequence: 1, status: "ACTIVE" },
+    });
+    const seats = await Promise.all(
+      ["1A", "1B", "1C", "1D", "1E", "1F"].map((seatNumber, i) =>
+        harness.prisma.seat.create({
+          data: { coachId: coach.id, seatNumber, row: 1, col: seatNumber.slice(-1), isWindow: i === 0, isAisle: i === 1 },
+        }),
+      ),
+    );
+    const schedule = await schedulesService.createSchedule({
+      trainId: train.id,
+      routeId: opts.routeId,
+      departureAt: opts.departureAt.toISOString(),
+      arrivalAt: opts.arrivalAt.toISOString(),
+      coachIds: [coach.id],
+    } as any);
+    return { schedule, seats };
+  }
+
+  async function hold(scheduleId: string, originStationId: string, destinationStationId: string, seatId: string, passengerId: string) {
+    return seatsService.holdSeats({
+      scheduleId,
+      originStationId,
+      destinationStationId,
+      passengers: [{ passengerId, seatId }],
+    } as any);
+  }
+
+  /** Holds several seats on the SAME leg in one SeatHold row (one holdId covers them all) —
+   * required when a single booking carries multiple travelers on one leg: holdSeats rejects a
+   * second call for the same passengerId+leg as a conflict, so multi-passenger holds must be
+   * one call with distinct passengerIds, not N sequential single-seat calls. */
+  async function holdMany(scheduleId: string, originStationId: string, destinationStationId: string, seatIds: string[]) {
+    return seatsService.holdSeats({
+      scheduleId,
+      originStationId,
+      destinationStationId,
+      passengers: seatIds.map((seatId, i) => ({ passengerId: `44444444-4444-4444-8444-40000000000${i}`, seatId })),
+    } as any);
+  }
+
+  function passenger(overrides: Partial<Record<string, any>> = {}) {
+    return {
+      passengerName: "Test Traveler",
+      dateOfBirth: "1990-01-01",
+      idDocumentType: IdDocumentType.PASSPORT,
+      passportNumber: "X123456",
+      passportCountry: "Djibouti",
+      nationality: "Djiboutian",
+      ...overrides,
+    };
+  }
+
+  const future = (mins: number) => new Date(Date.now() + mins * 60_000);
+
+  describe("ROUND_TRIP", () => {
+    it("creates a booking with correct fields for both legs", async () => {
+      const dep = future(180);
+      const arr = future(280);
+      const { schedule: outbound, seats: outSeats } = await createTestSchedule({ trainNumber: `RT-OB-${Date.now()}`, routeId: IDS.route, departureAt: dep, arrivalAt: arr });
+      const { schedule: ret, seats: retSeats } = await createTestSchedule({ trainNumber: `RT-RET-${Date.now()}`, routeId: reverseRouteId, departureAt: future(400), arrivalAt: future(480) });
+
+      const outHold = await hold(outbound.id, IDS.stationA, IDS.stationC, outSeats[0].id, "11111111-1111-4111-8111-100000000001");
+      const retHold = await hold(ret.id, IDS.stationC, IDS.stationA, retSeats[0].id, "11111111-1111-4111-8111-100000000001");
+
+      const result: any = await guestBookingService.createGuestBooking({
+        bookingType: "ROUND_TRIP",
+        scheduleId: outbound.id,
+        holdId: (outHold as any).holdId,
+        originStationId: IDS.stationA,
+        destinationStationId: IDS.stationC,
+        seatClassId: IDS.seatClassLocal,
+        returnScheduleId: ret.id,
+        returnHoldId: (retHold as any).holdId,
+        returnOriginStationId: IDS.stationC,
+        returnDestinationStationId: IDS.stationA,
+        passengers: [passenger({ seatId: outSeats[0].id, returnSeatId: retSeats[0].id })],
+      } as any);
+
+      expect(result.bookingType).toBe("ROUND_TRIP");
+      expect(result.returnScheduleId).toBe(ret.id);
+      expect(result.returnOriginStationId).toBe(IDS.stationC);
+      expect(result.returnDestinationStationId).toBe(IDS.stationA);
+      expect(result.totalMinor).toBeGreaterThan(0);
+
+      const seatRows = await harness.prisma.bookingSeat.findMany({ where: { bookingId: result.id } });
+      expect(seatRows).toHaveLength(2); // one BookingSeat per leg
+      expect(seatRows.map((s) => s.scheduleId).sort()).toEqual([outbound.id, ret.id].sort());
+    });
+
+    it("rejects a ROUND_TRIP missing return fields with the exact message", async () => {
+      const { schedule: outbound, seats } = await createTestSchedule({ trainNumber: `RT-MISS-${Date.now()}`, routeId: IDS.route, departureAt: future(180), arrivalAt: future(280) });
+      const outHold = await hold(outbound.id, IDS.stationA, IDS.stationC, seats[0].id, "11111111-1111-4111-8111-100000000002");
+
+      await expect(
+        guestBookingService.createGuestBooking({
+          bookingType: "ROUND_TRIP",
+          scheduleId: outbound.id,
+          holdId: (outHold as any).holdId,
+          originStationId: IDS.stationA,
+          destinationStationId: IDS.stationC,
+          seatClassId: IDS.seatClassLocal,
+          passengers: [passenger({ seatId: seats[0].id })],
+        } as any),
+      ).rejects.toThrow(/returnScheduleId, returnHoldId, returnOriginStationId and returnDestinationStationId are required/i);
+    });
+
+    // NOTE: a "first child travels free" test was attempted here and dropped — the
+    // fareMinor-by-seatId-presence branch (`p.seatId ? childUnitFare : 0`, commented "Free
+    // children have no seat (frontend excludes them from the DTO)") is UNREACHABLE in
+    // practice: every passenger row unconditionally goes through
+    // `seat: { connect: { id: p.seatId } } }` when the booking is created (confirmed in
+    // ONE_WAY at line ~367, ROUND_TRIP at ~874, TRANSIT at ~1075) — a passenger with no
+    // `seatId` makes that Prisma `connect` throw, so a truly seat-less "free child" can never
+    // reach the booking-creation step at all. FLAGGED, not fixed — see the final report.
+
+    it("two adults on the same booking are each charged the full per-leg fare", async () => {
+      const dep = future(180);
+      const { schedule: outbound, seats: outSeats } = await createTestSchedule({ trainNumber: `RT-2ADULT-OB-${Date.now()}`, routeId: IDS.route, departureAt: dep, arrivalAt: future(280) });
+      const { schedule: ret, seats: retSeats } = await createTestSchedule({ trainNumber: `RT-2ADULT-RET-${Date.now()}`, routeId: reverseRouteId, departureAt: future(400), arrivalAt: future(480) });
+
+      const outHold = await holdMany(outbound.id, IDS.stationA, IDS.stationC, [outSeats[0].id, outSeats[1].id]);
+      const retHold = await holdMany(ret.id, IDS.stationC, IDS.stationA, [retSeats[0].id, retSeats[1].id]);
+
+      const result: any = await guestBookingService.createGuestBooking({
+        bookingType: "ROUND_TRIP",
+        scheduleId: outbound.id,
+        holdId: (outHold as any).holdId,
+        originStationId: IDS.stationA,
+        destinationStationId: IDS.stationC,
+        seatClassId: IDS.seatClassLocal,
+        returnScheduleId: ret.id,
+        returnHoldId: (retHold as any).holdId,
+        returnOriginStationId: IDS.stationC,
+        returnDestinationStationId: IDS.stationA,
+        passengers: [
+          passenger({ seatId: outSeats[0].id, returnSeatId: retSeats[0].id, passengerName: "Adult One" }),
+          passenger({ seatId: outSeats[1].id, returnSeatId: retSeats[1].id, passengerName: "Adult Two" }),
+        ],
+      } as any);
+
+      expect(result.adultCount).toBe(2);
+      expect(result.childCount).toBe(0);
+      const seatFares = await harness.prisma.bookingSeat.findMany({ where: { bookingId: result.id } });
+      expect(seatFares).toHaveLength(4); // 2 passengers x 2 legs
+      const fareMinors = new Set(seatFares.map((s) => s.fareMinor));
+      expect(fareMinors.size).toBe(1); // every seat on every leg is the same base fare
+      expect([...fareMinors][0]).toBeGreaterThan(0);
+      const total = seatFares.reduce((sum, s) => sum + s.fareMinor, 0);
+      expect(result.totalMinor).toBe(total);
+    });
+  });
+
+  describe("TRANSIT", () => {
+    it("creates a single booking spanning leg-1 and leg-2 via the transit station", async () => {
+      const dep = future(180);
+      const { schedule: leg1, seats: leg1Seats } = await createTestSchedule({ trainNumber: `TR-L1-${Date.now()}`, routeId: IDS.route, departureAt: dep, arrivalAt: future(220) });
+      const { schedule: leg2, seats: leg2Seats } = await createTestSchedule({ trainNumber: `TR-L2-${Date.now()}`, routeId: IDS.route, departureAt: future(260), arrivalAt: future(320) });
+
+      const leg1Hold = await hold(leg1.id, IDS.stationA, IDS.stationB, leg1Seats[0].id, "22222222-2222-4222-8222-200000000001");
+      const leg2Hold = await hold(leg2.id, IDS.stationB, IDS.stationC, leg2Seats[0].id, "22222222-2222-4222-8222-200000000001");
+
+      const result: any = await guestBookingService.createGuestBooking({
+        bookingType: "TRANSIT",
+        scheduleId: leg1.id,
+        holdId: (leg1Hold as any).holdId,
+        originStationId: IDS.stationA,
+        destinationStationId: IDS.stationB,
+        seatClassId: IDS.seatClassLocal,
+        leg2ScheduleId: leg2.id,
+        leg2HoldId: (leg2Hold as any).holdId,
+        transitStationId: IDS.stationB,
+        leg2DestinationStationId: IDS.stationC,
+        passengers: [passenger({ seatId: leg1Seats[0].id, leg2SeatId: leg2Seats[0].id })],
+      } as any);
+
+      expect(result.bookingType).toBe("TRANSIT");
+      expect(result.originStationId).toBe(IDS.stationA);
+      expect(result.destinationStationId).toBe(IDS.stationC); // full journey span, not just leg-1
+      expect(result.leg2ScheduleId).toBe(leg2.id);
+      expect(result.leg2OriginStationId).toBe(IDS.stationB);
+      expect(result.leg2DestinationStationId).toBe(IDS.stationC);
+
+      const seatRows = await harness.prisma.bookingSeat.findMany({ where: { bookingId: result.id } });
+      expect(seatRows).toHaveLength(2);
+      expect(seatRows.map((s) => s.scheduleId).sort()).toEqual([leg1.id, leg2.id].sort());
+    });
+
+    it("rejects a TRANSIT missing leg-2 fields with the exact message", async () => {
+      const { schedule: leg1, seats } = await createTestSchedule({ trainNumber: `TR-MISS-${Date.now()}`, routeId: IDS.route, departureAt: future(180), arrivalAt: future(220) });
+      const leg1Hold = await hold(leg1.id, IDS.stationA, IDS.stationB, seats[0].id, "22222222-2222-4222-8222-200000000002");
+
+      await expect(
+        guestBookingService.createGuestBooking({
+          bookingType: "TRANSIT",
+          scheduleId: leg1.id,
+          holdId: (leg1Hold as any).holdId,
+          originStationId: IDS.stationA,
+          destinationStationId: IDS.stationB,
+          seatClassId: IDS.seatClassLocal,
+          passengers: [passenger({ seatId: seats[0].id })],
+        } as any),
+      ).rejects.toThrow(/leg2ScheduleId, leg2HoldId, transitStationId and leg2DestinationStationId are required/i);
+    });
+  });
+
+  describe("ROUND_TRIP_TRANSIT", () => {
+    it("creates a single booking spanning all 4 legs (outbound x2, return x2)", async () => {
+      const { schedule: obL1, seats: obL1Seats } = await createTestSchedule({ trainNumber: `RTT-OB1-${Date.now()}`, routeId: IDS.route, departureAt: future(180), arrivalAt: future(220) });
+      const { schedule: obL2, seats: obL2Seats } = await createTestSchedule({ trainNumber: `RTT-OB2-${Date.now()}`, routeId: IDS.route, departureAt: future(260), arrivalAt: future(320) });
+      const { schedule: retL1, seats: retL1Seats } = await createTestSchedule({ trainNumber: `RTT-RET1-${Date.now()}`, routeId: reverseRouteId, departureAt: future(500), arrivalAt: future(560) });
+      const { schedule: retL2, seats: retL2Seats } = await createTestSchedule({ trainNumber: `RTT-RET2-${Date.now()}`, routeId: reverseRouteId, departureAt: future(600), arrivalAt: future(660) });
+
+      const pid = "33333333-3333-4333-8333-300000000001";
+      const obL1Hold = await hold(obL1.id, IDS.stationA, IDS.stationB, obL1Seats[0].id, pid);
+      const obL2Hold = await hold(obL2.id, IDS.stationB, IDS.stationC, obL2Seats[0].id, pid);
+      const retL1Hold = await hold(retL1.id, IDS.stationC, IDS.stationB, retL1Seats[0].id, pid);
+      const retL2Hold = await hold(retL2.id, IDS.stationB, IDS.stationA, retL2Seats[0].id, pid);
+
+      const result: any = await guestBookingService.createGuestBooking({
+        bookingType: "ROUND_TRIP_TRANSIT",
+        scheduleId: obL1.id,
+        holdId: (obL1Hold as any).holdId,
+        originStationId: IDS.stationA,
+        destinationStationId: IDS.stationB,
+        seatClassId: IDS.seatClassLocal,
+        leg2ScheduleId: obL2.id,
+        leg2HoldId: (obL2Hold as any).holdId,
+        transitStationId: IDS.stationB,
+        leg2DestinationStationId: IDS.stationC,
+        returnScheduleId: retL1.id,
+        returnHoldId: (retL1Hold as any).holdId,
+        returnOriginStationId: IDS.stationC,
+        returnDestinationStationId: IDS.stationB,
+        returnLeg2ScheduleId: retL2.id,
+        returnLeg2HoldId: (retL2Hold as any).holdId,
+        returnTransitStationId: IDS.stationB,
+        returnLeg2DestinationStationId: IDS.stationA,
+        passengers: [passenger({
+          seatId: obL1Seats[0].id,
+          leg2SeatId: obL2Seats[0].id,
+          returnSeatId: retL1Seats[0].id,
+          returnLeg2SeatId: retL2Seats[0].id,
+        })],
+      } as any);
+
+      expect(result.bookingType).toBe("ROUND_TRIP_TRANSIT");
+      const seatRows = await harness.prisma.bookingSeat.findMany({ where: { bookingId: result.id } });
+      expect(seatRows).toHaveLength(4);
+      expect(seatRows.map((s) => s.scheduleId).sort()).toEqual([obL1.id, obL2.id, retL1.id, retL2.id].sort());
+    });
+
+    it("rejects a ROUND_TRIP_TRANSIT missing any leg's fields with the exact message", async () => {
+      const { schedule: obL1, seats } = await createTestSchedule({ trainNumber: `RTT-MISS-${Date.now()}`, routeId: IDS.route, departureAt: future(180), arrivalAt: future(220) });
+      const obL1Hold = await hold(obL1.id, IDS.stationA, IDS.stationB, seats[0].id, "33333333-3333-4333-8333-300000000002");
+
+      await expect(
+        guestBookingService.createGuestBooking({
+          bookingType: "ROUND_TRIP_TRANSIT",
+          scheduleId: obL1.id,
+          holdId: (obL1Hold as any).holdId,
+          originStationId: IDS.stationA,
+          destinationStationId: IDS.stationB,
+          seatClassId: IDS.seatClassLocal,
+          passengers: [passenger({ seatId: seats[0].id })],
+        } as any),
+      ).rejects.toThrow(/ROUND_TRIP_TRANSIT requires all 4 holds and all transit\/return station fields/i);
+    });
+  });
+});
diff --git a/apps/edr-passenger-api/test/config-validation.e2e-spec.ts b/apps/edr-passenger-api/test/config-validation.e2e-spec.ts
index d17f568a1..2bdd4267b 100644
--- a/apps/edr-passenger-api/test/config-validation.e2e-spec.ts
+++ b/apps/edr-passenger-api/test/config-validation.e2e-spec.ts
@@ -3,10 +3,13 @@
  * enforces exactly these class-validator DTOs, so validating the DTOs directly reproduces what a
  * raw API call (bypassing the HTML-only frontend checks) would be allowed to submit.
  *   H1 🔴 CreateFareRuleDto.baseFareMinor accepts NEGATIVE (no @Min) — while the sibling
- *          CreateSegmentFareDto.baseFareMinor has @Min(0) (inconsistent).
- *   H2 🔴 CreateSeatClassDto.basePrice accepts negative/zero (no @Min) — drives every distance fare.
- *   H4 🔴 CreatePromotionDto.percentOff accepts 200 (no @Max(100)) → discount > subtotal.
+ *          CreateSegmentFareDto.baseFareMinor has @Min(0) (inconsistent). Still unfixed.
+ *   H2 ✅ FIXED (was 🔴 "CreateSeatClassDto.basePrice accepts negative/zero, no @Min"):
+ *          seat-classes.dto.ts now has @Min(0) on basePrice. Test updated to assert the fix.
+ *   H4 ✅ FIXED (was 🔴 "CreatePromotionDto.percentOff accepts 200, no @Max(100)"):
+ *          promos.dto.ts now has @Min(0) @Max(100) on percentOff. Test updated to assert the fix.
  *   H5 🔴 CreatePromotionDto.validUntil is @IsString (not @IsDateString) → accepts non-dates.
+ *          Still unfixed.
  */
 import "reflect-metadata";
 import { plainToInstance } from "class-transformer";
@@ -44,23 +47,23 @@ describe("Backoffice config validation (Suite H)", () => {
     expect(await erroredProps(dto)).toContain("baseFareMinor");
   });
 
-  it("H2 🔴 CreateSeatClassDto accepts a negative basePrice (no @Min)", async () => {
+  it("H2 ✅ CreateSeatClassDto rejects a negative basePrice (@Min(0))", async () => {
     const dto = plainToInstance(CreateSeatClassDto, {
       coachTypeId: "ct-1",
       name: "Economy",
       basePrice: -5000,
     });
-    expect(await erroredProps(dto)).not.toContain("basePrice");
+    expect(await erroredProps(dto)).toContain("basePrice");
   });
 
-  it("H4 🔴 CreatePromotionDto accepts percentOff = 200 (no @Max(100))", async () => {
+  it("H4 ✅ CreatePromotionDto rejects percentOff = 200 (@Max(100))", async () => {
     const dto = plainToInstance(CreatePromotionDto, {
       code: "OVER",
       title: "Overshoot",
       percentOff: 200,
       validUntil: "2026-12-31T23:59:59Z",
     });
-    expect(await erroredProps(dto)).not.toContain("percentOff");
+    expect(await erroredProps(dto)).toContain("percentOff");
   });
 
   it("H5 🔴 CreatePromotionDto.validUntil accepts a non-date string (@IsString, not @IsDateString)", async () => {
diff --git a/apps/edr-passenger-api/test/critical-repro.e2e-spec.ts b/apps/edr-passenger-api/test/critical-repro.e2e-spec.ts
index 83a7d8d6b..8058066c7 100644
--- a/apps/edr-passenger-api/test/critical-repro.e2e-spec.ts
+++ b/apps/edr-passenger-api/test/critical-repro.e2e-spec.ts
@@ -2,8 +2,10 @@
  * Executable reproducers for the highest-severity findings that were previously inspection-only.
  * All Tier-2 (direct instantiation, real Prisma + stubbed collaborators).
  *
- *   C-1 🔴 BookingsService trusts client `reviewedTotalMinor`: a booking is stored with totalMinor=1
- *          while the server fare engine computed ~30000.
+ *   C-1 ✅ FIXED (was 🔴 "BookingsService trusts client reviewedTotalMinor: a booking is
+ *          stored with totalMinor=1 while the server fare engine computed ~30000") —
+ *          createOneWayBooking now runs assertTotalNotUnderAuthoritative before persisting;
+ *          a forged low total is rejected, not stored. Test below updated to assert this.
  *   C-4 🔴 finalizePaymentSuccess confirms a booking without comparing the paid amount: an intent for
  *          1 minor confirms a 30000 booking.
  *   C-6 🔴 Concurrent WALLET payments double-spend one balance (no row lock): a wallet funded for one
@@ -164,14 +166,16 @@ describe("Critical reproducers (Tier-2)", () => {
       ],
     };
 
-    const result: any = await (bookings as any).createOneWayBooking(dto);
+    // FIXED (was 🔴): createOneWayBooking now runs the forged reviewedTotalMinor through
+    // assertTotalNotUnderAuthoritative before ever writing a Booking row — a client total
+    // below the server-computed fare (minus a 1% rounding tolerance) is rejected outright,
+    // not silently persisted. Confirmed by reading bookings.service.ts's C-1 guard comment.
+    await expect((bookings as any).createOneWayBooking(dto)).rejects.toThrow(
+      /Booking total does not match the authoritative fare/i,
+    );
 
-    // The server engine computed the real fare…
-    expect(result.fareBreakdown.totalMinor).toBeGreaterThanOrEqual(30_000);
-    // …but the booking was stored at the client's forged 1 minor.
-    expect(result.totalMinor).toBe(1);
-    const stored = await prisma.booking.findUnique({ where: { id: result.id } });
-    expect(stored?.totalMinor).toBe(1);
+    const stored = await prisma.booking.findFirst({ where: { scheduleId: schedule.id, passengerId: passenger.id } });
+    expect(stored).toBeNull(); // no under-priced booking left behind
   });
 
   // ── C-4 ──────────────────────────────────────────────────────────────────
diff --git a/apps/edr-passenger-api/test/currency-through-booking.e2e-spec.ts b/apps/edr-passenger-api/test/currency-through-booking.e2e-spec.ts
new file mode 100644
index 000000000..b3ab0a76a
--- /dev/null
+++ b/apps/edr-passenger-api/test/currency-through-booking.e2e-spec.ts
@@ -0,0 +1,146 @@
+/**
+ * Currency conversion through a REAL booking — CurrencyService/FareEngineService are only
+ * exercised in isolation elsewhere (pricing-currency.e2e-spec.ts, pricing-fare-engine.e2e-spec.ts);
+ * nothing previously drove an actual GuestBookingService.createGuestBooking() call in a
+ * non-ETB displayCurrency and asserted the converted amount.
+ *
+ * Also covers the consequence of the C2 fix documented in pricing-currency.e2e-spec.ts:
+ * CurrencyService.getExchangeRate() now fails closed (throws) on a missing rate instead of
+ * silently pricing at parity — confirms that failure mode actually propagates out of booking
+ * creation as a real rejection, not a silently wrong charge.
+ */
+import { IdDocumentType, Currency } from "@prisma/client";
+import { SchedulesService } from "../src/modules/schedules/schedules.service";
+import { SeatsService } from "../src/modules/seats/seats.service";
+import { CurrencyService } from "../src/modules/currency/currency.service";
+import { FareEngineService } from "../src/modules/fare-engine/fare-engine.service";
+import { SystemConfigService } from "../src/modules/system-config/system-config.service";
+import { GuestBookingService } from "../src/modules/bookings/guest-booking.service";
+import { createServiceHarness, ServiceHarness } from "./setup/slim-app";
+import { IDS, resetAndSeedCore, USD_TO_ETB, ETB_TO_DJF } from "./fixtures/seed-core";
+
+function asyncStub(): any {
+  return new Proxy({}, { get: () => async () => undefined });
+}
+
+describe("Currency conversion through a real booking", () => {
+  let harness: ServiceHarness;
+  let schedulesService: SchedulesService;
+  let seatsService: SeatsService;
+  let guestBookingService: GuestBookingService;
+
+  beforeAll(async () => {
+    harness = await createServiceHarness();
+    schedulesService = await harness.moduleRef.resolve(SchedulesService);
+    const currencyService = harness.moduleRef.get(CurrencyService);
+    const fareEngine = harness.moduleRef.get(FareEngineService);
+    const systemConfig = new SystemConfigService(harness.prisma as any);
+
+    seatsService = new SeatsService(harness.prisma as any, asyncStub(), systemConfig, asyncStub(), asyncStub());
+    guestBookingService = new GuestBookingService(
+      harness.prisma as any,
+      seatsService,
+      asyncStub(),
+      currencyService,
+      asyncStub(),
+      fareEngine,
+      { emit: () => true } as any,
+      asyncStub(),
+      asyncStub(),
+      asyncStub(),
+    );
+  });
+
+  afterAll(async () => {
+    await harness?.close();
+  });
+
+  beforeEach(async () => {
+    await resetAndSeedCore(harness.prisma);
+  });
+
+  const future = (mins: number) => new Date(Date.now() + mins * 60_000);
+
+  async function createTestSchedule(trainNumber: string) {
+    const train = await harness.prisma.train.create({ data: { number: trainNumber, name: "Test" } });
+    const coach = await harness.prisma.coach.create({
+      data: { coachTypeId: IDS.coachType, number: `${trainNumber}-C1`, capacity: 4, sequence: 1, status: "ACTIVE" },
+    });
+    const seats = await Promise.all(
+      ["1A", "1B", "1C"].map((seatNumber, i) =>
+        harness.prisma.seat.create({ data: { coachId: coach.id, seatNumber, row: 1, col: seatNumber.slice(-1), isWindow: i === 0, isAisle: i === 1 } }),
+      ),
+    );
+    const schedule = await schedulesService.createSchedule({
+      trainId: train.id, routeId: IDS.route,
+      departureAt: future(180).toISOString(), arrivalAt: future(220).toISOString(),
+      coachIds: [coach.id],
+    } as any);
+    return { schedule, seats };
+  }
+
+  async function bookInCurrency(scheduleId: string, seatId: string, displayCurrency: Currency, passengerId: string, nationality: "Djiboutian" | "Ethiopian" = "Djiboutian") {
+    const hold = await seatsService.holdSeats({
+      scheduleId, originStationId: IDS.stationA, destinationStationId: IDS.stationB,
+      passengers: [{ passengerId, seatId }],
+    } as any);
+    return guestBookingService.createGuestBooking({
+      scheduleId,
+      holdId: (hold as any).holdId,
+      originStationId: IDS.stationA,
+      destinationStationId: IDS.stationB,
+      seatClassId: IDS.seatClassLocal,
+      displayCurrency,
+      passengers: [{
+        seatId, passengerName: "Test Traveler", dateOfBirth: "1990-01-01",
+        idDocumentType: IdDocumentType.PASSPORT, passportNumber: "X123456", passportCountry: "Djibouti", nationality,
+      }],
+    } as any) as Promise<any>;
+  }
+
+  it("charges the SAME ETB amount regardless of displayCurrency, but displays it converted by the seeded rate", async () => {
+    const { schedule, seats } = await createTestSchedule(`CUR-${Date.now()}`);
+
+    const etbBooking = await bookInCurrency(schedule.id, seats[0].id, Currency.ETB, "66666666-6666-4666-8666-600000000001");
+    const usdBooking = await bookInCurrency(schedule.id, seats[1].id, Currency.USD, "66666666-6666-4666-8666-600000000002");
+    const djfBooking = await bookInCurrency(schedule.id, seats[2].id, Currency.DJF, "66666666-6666-4666-8666-600000000003");
+
+    // ETB charge basis (totalMinor) is identical across all three — displayCurrency only
+    // affects what's SHOWN to the passenger, never the authoritative ETB amount collected.
+    expect(usdBooking.totalMinor).toBe(etbBooking.totalMinor);
+    expect(djfBooking.totalMinor).toBe(etbBooking.totalMinor);
+    expect(etbBooking.currency).toBe("ETB");
+    expect(usdBooking.currency).toBe("ETB");
+    expect(djfBooking.currency).toBe("ETB");
+
+    // displayTotalMinor derived from the exact seeded rates (see seed-core.ts).
+    expect(etbBooking.displayTotalMinor).toBe(etbBooking.totalMinor);
+    expect(usdBooking.displayTotalMinor).toBe(etbBooking.totalMinor * (1 / USD_TO_ETB));
+    expect(djfBooking.displayTotalMinor).toBe(etbBooking.totalMinor * ETB_TO_DJF);
+
+    expect(etbBooking.displayCurrency).toBe("ETB");
+    expect(usdBooking.displayCurrency).toBe("USD");
+    expect(djfBooking.displayCurrency).toBe("DJF");
+  });
+
+  it("rejects booking creation when the requested displayCurrency has no configured FX rate (fails closed, doesn't price at parity)", async () => {
+    const { schedule, seats } = await createTestSchedule(`CUR-NORATE-${Date.now()}`);
+    // Remove BOTH directions of the ETB<->DJF rate. Nationality is Ethiopian (not Djiboutian)
+    // specifically so FareEngineService's OWN internal billing-currency conversion (tied to
+    // nationality, resolves to ETB for an Ethiopian passenger — a same-currency no-op that
+    // never touches the DB) doesn't also need this rate; only the OUTER
+    // GuestBookingService.createGuestOneWayBooking's displayCurrency conversion does. This
+    // isolates the failure to that one call rather than fare calculation itself.
+    await harness.prisma.currencyExchangeRate.deleteMany({
+      where: { OR: [{ fromCurrency: "ETB", toCurrency: "DJF" }, { fromCurrency: "DJF", toCurrency: "ETB" }] },
+    });
+
+    await expect(
+      bookInCurrency(schedule.id, seats[0].id, Currency.DJF, "66666666-6666-4666-8666-600000000004", "Ethiopian"),
+    ).rejects.toThrow(/No exchange rate configured/i);
+
+    // No half-created booking left behind by the failed conversion.
+    const orphan = await harness.prisma.booking.findFirst({ where: { scheduleId: schedule.id, displayCurrency: "DJF" } });
+    expect(orphan).toBeNull();
+  });
+});
diff --git a/apps/edr-passenger-api/test/money-integrity.e2e-spec.ts b/apps/edr-passenger-api/test/money-integrity.e2e-spec.ts
index 02ca87863..5a91601ab 100644
--- a/apps/edr-passenger-api/test/money-integrity.e2e-spec.ts
+++ b/apps/edr-passenger-api/test/money-integrity.e2e-spec.ts
@@ -85,6 +85,7 @@ describe("Money integrity (Tier-2 direct instantiation)", () => {
       prisma as any,
       asyncStub(), // dataSource
       asyncStub(), // seatsService
+      asyncStub(), // ticketsService — constructor gained this param since this test was written
       { emit: () => true } as any, // eventEmitter
       asyncStub(), // verifaydaService
       asyncStub(), // currencyService
diff --git a/apps/edr-passenger-api/test/payments-webhook-refund.e2e-spec.ts b/apps/edr-passenger-api/test/payments-webhook-refund.e2e-spec.ts
new file mode 100644
index 000000000..f4f80c694
--- /dev/null
+++ b/apps/edr-passenger-api/test/payments-webhook-refund.e2e-spec.ts
@@ -0,0 +1,249 @@
+/**
+ * Payments webhook + non-wallet provider flow — PaymentsService.handlePaymentEvent() (the
+ * real "webhook" entry point, invoked by both the RabbitMQ consumer and
+ * InternalPaymentsController — see payment-events.consumer.ts /
+ * internal-payments.controller.ts) had zero e2e coverage before this suite. Also exercises
+ * initiatePayment() for a non-wallet (provider-routed) method, mocking PaymentClientService at
+ * the boundary — no real payment provider is contacted.
+ *
+ * Refund disbursement is deliberately NOT re-tested here: money-integrity.e2e-spec.ts already
+ * covers `cancel()` computing an 80% refund that's never actually disbursed (no PaymentRefund
+ * row, no wallet credit) in detail — re-run that suite rather than duplicating it. Confirmed
+ * still true as of this session (unrelated to the module changed here).
+ *
+ * NOTE: apps/edr-passenger-api/src/modules/payments/payments.e2e-spec.ts (an existing "E2E"
+ * suite that boots the full AppModule over HTTP) is never actually executed by any script —
+ * it lives outside test/jest-e2e.json's rootDir (`test/`) and doesn't match the plain `test`
+ * script's `.spec.ts$` regex either (the filename ends `...e2e-spec.ts`, not `...spec.ts`
+ * immediately preceded by a dot). Flagging as an orphaned test file, not fixed here.
+ */
+import { IdDocumentType, PaymentIntentStatus, PaymentMethodType } from "@prisma/client";
+import { PaymentService as PaymentServiceEnum, PaymentReferenceType, ProviderMethod, ProviderPaymentStatus } from "@edr/types";
+import { SchedulesService } from "../src/modules/schedules/schedules.service";
+import { SeatsService } from "../src/modules/seats/seats.service";
+import { TicketsService } from "../src/modules/tickets/tickets.service";
+import { PaymentsService } from "../src/modules/payments/payments.service";
+import { CurrencyService } from "../src/modules/currency/currency.service";
+import { FareEngineService } from "../src/modules/fare-engine/fare-engine.service";
+import { SystemConfigService } from "../src/modules/system-config/system-config.service";
+import { GuestBookingService } from "../src/modules/bookings/guest-booking.service";
+import { createServiceHarness, ServiceHarness } from "./setup/slim-app";
+import { IDS, resetAndSeedCore } from "./fixtures/seed-core";
+
+function asyncStub(): any {
+  return new Proxy({}, { get: () => async () => undefined });
+}
+
+describe("Payments — webhook idempotency and non-wallet initiate flow", () => {
+  let harness: ServiceHarness;
+  let schedulesService: SchedulesService;
+  let seatsService: SeatsService;
+  let ticketsService: TicketsService;
+  let guestBookingService: GuestBookingService;
+  let paymentClient: { initiate: jest.Mock };
+  let paymentsService: PaymentsService;
+
+  beforeAll(async () => {
+    harness = await createServiceHarness();
+    schedulesService = await harness.moduleRef.resolve(SchedulesService);
+    const currencyService = harness.moduleRef.get(CurrencyService);
+    const fareEngine = harness.moduleRef.get(FareEngineService);
+    const systemConfig = new SystemConfigService(harness.prisma as any);
+
+    seatsService = new SeatsService(harness.prisma as any, asyncStub(), systemConfig, asyncStub(), asyncStub());
+    ticketsService = new TicketsService(harness.prisma as any, asyncStub(), systemConfig, asyncStub(), asyncStub());
+    paymentClient = { initiate: jest.fn() };
+    paymentsService = new PaymentsService(
+      harness.prisma as any,
+      seatsService,
+      ticketsService,
+      { emit: () => true } as any,
+      paymentClient as any,
+      currencyService,
+      asyncStub(),
+    );
+    guestBookingService = new GuestBookingService(
+      harness.prisma as any,
+      seatsService,
+      asyncStub(),
+      currencyService,
+      asyncStub(),
+      fareEngine,
+      { emit: () => true } as any,
+      paymentsService,
+      asyncStub(),
+      asyncStub(),
+    );
+  });
+
+  afterAll(async () => {
+    await harness?.close();
+  });
+
+  beforeEach(async () => {
+    await resetAndSeedCore(harness.prisma);
+    paymentClient.initiate.mockReset();
+  });
+
+  const future = (mins: number) => new Date(Date.now() + mins * 60_000);
+
+  async function createTestSchedule(trainNumber: string) {
+    const train = await harness.prisma.train.create({ data: { number: trainNumber, name: "Test" } });
+    const coach = await harness.prisma.coach.create({
+      data: { coachTypeId: IDS.coachType, number: `${trainNumber}-C1`, capacity: 4, sequence: 1, status: "ACTIVE" },
+    });
+    const seats = await Promise.all(
+      ["1A", "1B"].map((seatNumber, i) =>
+        harness.prisma.seat.create({ data: { coachId: coach.id, seatNumber, row: 1, col: seatNumber.slice(-1), isWindow: i === 0, isAisle: i === 1 } }),
+      ),
+    );
+    const schedule = await schedulesService.createSchedule({
+      trainId: train.id, routeId: IDS.route,
+      departureAt: future(180).toISOString(), arrivalAt: future(220).toISOString(),
+      coachIds: [coach.id],
+    } as any);
+    return { schedule, seats };
+  }
+
+  async function createOneWayBooking(scheduleId: string, seatId: string, passengerId: string) {
+    const hold = await seatsService.holdSeats({
+      scheduleId, originStationId: IDS.stationA, destinationStationId: IDS.stationB,
+      passengers: [{ passengerId, seatId }],
+    } as any);
+    return guestBookingService.createGuestBooking({
+      scheduleId, holdId: (hold as any).holdId,
+      originStationId: IDS.stationA, destinationStationId: IDS.stationB,
+      seatClassId: IDS.seatClassLocal,
+      passengers: [{
+        seatId, passengerName: "Test Traveler", dateOfBirth: "1990-01-01",
+        idDocumentType: IdDocumentType.PASSPORT, passportNumber: "X123456", passportCountry: "Djibouti", nationality: "Djiboutian",
+      }],
+    } as any) as Promise<any>;
+  }
+
+  function webhookEvent(booking: any, overrides: Partial<Record<string, any>> = {}) {
+    return {
+      version: 1 as const,
+      eventId: `evt-${Math.random().toString(36).slice(2)}`,
+      eventType: "payment.succeeded" as const,
+      occurredAt: new Date().toISOString(),
+      service: PaymentServiceEnum.PASSENGER,
+      intentId: `remote-intent-${Math.random().toString(36).slice(2)}`,
+      referenceType: PaymentReferenceType.BOOKING,
+      referenceId: booking.id,
+      merchantOrderId: booking.bookingRef,
+      provider: ProviderMethod.TELEBIRR,
+      amountMinor: booking.displayTotalMinor ?? booking.totalMinor,
+      currency: booking.displayCurrency ?? "ETB",
+      ...overrides,
+    };
+  }
+
+  describe("handlePaymentEvent() — webhook", () => {
+    it("delivering the same success event twice confirms the booking once, not twice", async () => {
+      const { schedule, seats } = await createTestSchedule(`WH-DUP-${Date.now()}`);
+      const booking = await createOneWayBooking(schedule.id, seats[0].id, "77777777-7777-4777-8777-700000000001");
+
+      const first = await paymentsService.handlePaymentEvent(webhookEvent(booking) as any);
+      expect(first.processed).toBe(true);
+
+      const second = await paymentsService.handlePaymentEvent(webhookEvent(booking, { eventId: "evt-redelivered" }) as any);
+      expect(second.processed).toBe(true);
+
+      const refreshedBooking = await harness.prisma.booking.findUnique({ where: { id: booking.id } });
+      expect(refreshedBooking?.status).toBe("CONFIRMED");
+
+      const intents = await harness.prisma.paymentIntent.findMany({ where: { bookingId: booking.id } });
+      expect(intents).toHaveLength(1);
+      expect(intents[0].status).toBe(PaymentIntentStatus.SUCCEEDED);
+
+      const tickets = await harness.prisma.ticket.findMany({ where: { bookingId: booking.id } });
+      expect(tickets).toHaveLength(1); // NOT duplicated on redelivery
+    });
+
+    it("refuses to confirm on a short (underpaid) settlement", async () => {
+      const { schedule, seats } = await createTestSchedule(`WH-SHORT-${Date.now()}`);
+      const booking = await createOneWayBooking(schedule.id, seats[0].id, "77777777-7777-4777-8777-700000000002");
+      const expected = booking.displayTotalMinor ?? booking.totalMinor;
+
+      const result = await paymentsService.handlePaymentEvent(
+        webhookEvent(booking, { amountMinor: Math.round(expected * 0.5) }) as any,
+      );
+
+      expect(result.processed).toBe(false);
+      expect((result as any).reason).toBe("amount-mismatch");
+
+      const refreshedBooking = await harness.prisma.booking.findUnique({ where: { id: booking.id } });
+      expect(refreshedBooking?.status).toBe("PENDING_PAYMENT");
+      const succeededIntents = await harness.prisma.paymentIntent.count({ where: { bookingId: booking.id, status: PaymentIntentStatus.SUCCEEDED } });
+      expect(succeededIntents).toBe(0);
+    });
+
+    it("payment.failed marks the intent FAILED without confirming the booking", async () => {
+      const { schedule, seats } = await createTestSchedule(`WH-FAILED-${Date.now()}`);
+      const booking = await createOneWayBooking(schedule.id, seats[0].id, "77777777-7777-4777-8777-700000000003");
+      await harness.prisma.paymentIntent.create({
+        data: { bookingId: booking.id, amountMinor: booking.totalMinor, currency: "ETB", method: PaymentMethodType.TELEBIRR, status: PaymentIntentStatus.PROCESSING },
+      });
+
+      const result = await paymentsService.handlePaymentEvent(
+        webhookEvent(booking, { eventType: "payment.failed", failureCode: "INSUFFICIENT_FUNDS", failureMessage: "Declined" }) as any,
+      );
+      expect(result.processed).toBe(true);
+
+      const intent = await harness.prisma.paymentIntent.findUnique({ where: { bookingId: booking.id } });
+      expect(intent?.status).toBe(PaymentIntentStatus.FAILED);
+      const refreshedBooking = await harness.prisma.booking.findUnique({ where: { id: booking.id } });
+      expect(refreshedBooking?.status).toBe("PENDING_PAYMENT");
+    });
+  });
+
+  describe("initiatePayment() — non-wallet (provider-routed) method", () => {
+    it("an instantly-settled provider response (e.g. TELEBIRR) converges the booking immediately, same as a webhook would", async () => {
+      const { schedule, seats } = await createTestSchedule(`INIT-NONWALLET-${Date.now()}`);
+      const booking = await createOneWayBooking(schedule.id, seats[0].id, "77777777-7777-4777-8777-700000000004");
+
+      paymentClient.initiate.mockResolvedValue({
+        intentId: "remote-intent-1",
+        status: ProviderPaymentStatus.SUCCEEDED,
+        provider: ProviderMethod.TELEBIRR,
+        merchantOrderId: booking.bookingRef,
+        amountMinor: booking.totalMinor / 100,
+        currency: "ETB",
+        providerTxnId: "TXN-123",
+        paidAt: new Date().toISOString(),
+      });
+
+      const response = await paymentsService.initiatePayment({ bookingId: booking.id, method: "TELEBIRR", platform: "web" } as any);
+      expect(paymentClient.initiate).toHaveBeenCalledTimes(1);
+      expect(response.status).toBe(PaymentIntentStatus.SUCCEEDED);
+
+      const refreshedBooking = await harness.prisma.booking.findUnique({ where: { id: booking.id } });
+      expect(refreshedBooking?.status).toBe("CONFIRMED");
+      const tickets = await harness.prisma.ticket.findMany({ where: { bookingId: booking.id } });
+      expect(tickets).toHaveLength(1);
+    });
+
+    it("a REQUIRES_ACTION provider response leaves the booking PENDING_PAYMENT and surfaces the clientAction", async () => {
+      const { schedule, seats } = await createTestSchedule(`INIT-PENDING-${Date.now()}`);
+      const booking = await createOneWayBooking(schedule.id, seats[0].id, "77777777-7777-4777-8777-700000000005");
+
+      paymentClient.initiate.mockResolvedValue({
+        intentId: "remote-intent-2",
+        status: ProviderPaymentStatus.REQUIRES_ACTION,
+        provider: ProviderMethod.TELEBIRR,
+        merchantOrderId: booking.bookingRef,
+        amountMinor: booking.totalMinor / 100,
+        currency: "ETB",
+        clientAction: { type: "REDIRECT", url: "https://provider.example/pay/abc" },
+      });
+
+      const response = await paymentsService.initiatePayment({ bookingId: booking.id, method: "TELEBIRR", platform: "web" } as any);
+      expect(response.status).toBe(PaymentIntentStatus.REQUIRES_ACTION);
+      expect((response as any).clientAction?.type).toBe("REDIRECT");
+
+      const refreshedBooking = await harness.prisma.booking.findUnique({ where: { id: booking.id } });
+      expect(refreshedBooking?.status).toBe("PENDING_PAYMENT");
+    });
+  });
+});
diff --git a/apps/edr-passenger-api/test/pricing-currency.e2e-spec.ts b/apps/edr-passenger-api/test/pricing-currency.e2e-spec.ts
index 2490366b8..e68231852 100644
--- a/apps/edr-passenger-api/test/pricing-currency.e2e-spec.ts
+++ b/apps/edr-passenger-api/test/pricing-currency.e2e-spec.ts
@@ -1,7 +1,12 @@
 /**
  * Currency / FX suite (matrix Suite C). Exercises CurrencyService directly.
- *   C2 🔴 missing rate: getExchangeRate() silently returns 1.0 while getRateOrThrow() throws —
- *         the display path degrades but the charge path errors on the SAME condition (divergence).
+ *   C2 ✅ FIXED (was 🔴): getExchangeRate() used to silently return 1.0 on a missing rate —
+ *         now fails closed with the same BadRequestException getRateOrThrow() always threw
+ *         (see the "H-2: fail closed" comment in currency.service.ts). C2/C2b below were
+ *         found still asserting the OLD buggy behavior (`resolves.toBe(1.0)`) and were
+ *         themselves failing as a result — updated to assert the current, correct behavior.
+ *         Do not revert getExchangeRate to silently return 1.0 to make an old version of
+ *         this test pass; that would reintroduce a real underpricing bug.
  *   C3 🔴 a future-dated rate is applied immediately (no `effectiveDate <= now` filter).
  *   C5 🔴 conversion routines disagree on units: displayMinorToChargeMajor / convertMinorToChargeMajor
  *         return MAJOR units, convertEtbMinorToChargeMinor returns MINOR — a 100x unit landmine both
@@ -26,23 +31,25 @@ describe("Pricing — CurrencyService (Suite C)", () => {
     await resetAndSeedCore(harness.prisma);
   });
 
-  it("C2 🔴 same DB state, 100x divergence: getExchangeRate → 1.0, getRateOrThrow → 100 (via inverse)", async () => {
+  it("C2 ✅ getExchangeRate now fails closed on a missing DIRECT rate, same as getRateOrThrow (no more silent 1.0)", async () => {
     // Remove only the DIRECT USD→ETB row; the inverse ETB→USD (0.01) from the fixture stays.
+    // getExchangeRate has no inverse-rate fallback at all (unlike getRateOrThrow, which does)
+    // — so it correctly throws here even though a usable inverse rate technically exists.
     await harness.prisma.currencyExchangeRate.deleteMany({
       where: { fromCurrency: "USD", toCurrency: "ETB" },
     });
 
-    // Display/fare path (getExchangeRate) has NO inverse fallback → silently returns 1.0 (wrong).
-    await expect(currency.getExchangeRate("USD" as any, "ETB" as any)).resolves.toBe(1.0);
+    await expect(currency.getExchangeRate("USD" as any, "ETB" as any)).rejects.toThrow(/No exchange rate configured/i);
 
-    // Charge path (getRateOrThrow) DOES fall back to the inverse → 1 / 0.01 = 100 (correct).
+    // getRateOrThrow DOES fall back to the inverse → 1 / 0.01 = 100 (correct) — this divergence
+    // (one method has an inverse fallback, the other doesn't) is a separate, real inconsistency
+    // from the old "silent 1.0" bug; flagging it, not fixing it here.
     await expect(
       currency.getRateOrThrow("USD" as any, "ETB" as any),
     ).resolves.toBe(USD_TO_ETB);
-    // → the display fare and the charged amount for the same trip differ by 100x.
   });
 
-  it("C2b 🔴 truly-missing pair: getExchangeRate → 1.0 (silent), getRateOrThrow → throws", async () => {
+  it("C2b ✅ truly-missing pair: both getExchangeRate and getRateOrThrow fail closed", async () => {
     await harness.prisma.currencyExchangeRate.deleteMany({
       where: {
         OR: [
@@ -51,7 +58,7 @@ describe("Pricing — CurrencyService (Suite C)", () => {
         ],
       },
     });
-    await expect(currency.getExchangeRate("USD" as any, "ETB" as any)).resolves.toBe(1.0);
+    await expect(currency.getExchangeRate("USD" as any, "ETB" as any)).rejects.toThrow(/No exchange rate configured/i);
     await expect(
       currency.getRateOrThrow("USD" as any, "ETB" as any),
     ).rejects.toThrow(/No exchange rate/i);
diff --git a/apps/edr-passenger-api/test/pricing-fare-engine.e2e-spec.ts b/apps/edr-passenger-api/test/pricing-fare-engine.e2e-spec.ts
index c519d3856..269a21c59 100644
--- a/apps/edr-passenger-api/test/pricing-fare-engine.e2e-spec.ts
+++ b/apps/edr-passenger-api/test/pricing-fare-engine.e2e-spec.ts
@@ -1,8 +1,13 @@
 /**
  * Reference pricing suite — proves the slim harness boots and exercises FareEngineService directly.
- * Also confirms two matrix findings against the running engine:
+ * Also confirms matrix findings against the running engine:
  *   D1 — a promo with percentOff > 100 drives the total NEGATIVE (no clamp at 0).
- *   C1 — a missing USD→ETB FX rate is silently substituted with 1.0 (fares collapse ~100x).
+ *   C1 ✅ FIXED (was 🔴 "missing USD→ETB FX rate is silently substituted with 1.0, fares
+ *        collapse ~100x"): CurrencyService.getExchangeRate() now fails closed on a missing
+ *        rate (see the "H-2: fail closed" comment in currency.service.ts, and
+ *        pricing-currency.e2e-spec.ts's C2/C2b) — FareEngineService.calculate() calls it
+ *        internally, so a missing rate now correctly rejects the fare calculation instead of
+ *        silently underpricing it. Updated below to assert the current, correct behavior.
  */
 import { FareEngineService } from "../src/modules/fare-engine/fare-engine.service";
 import {
@@ -114,18 +119,15 @@ describe("Pricing — FareEngineService (slim harness)", () => {
     expect(withPromo.totalMinor).toBe(base.totalMinor - 5000);
   });
 
-  it("C1 🔴 missing USD→ETB rate silently falls back to 1.0 (fare collapses ~100x)", async () => {
+  it("C1 ✅ a missing USD→ETB rate now rejects the fare calculation instead of silently pricing at parity", async () => {
     const withRate = await fareEngine.calculate(baseDto() as any);
+    expect(withRate.totalMinor).toBeGreaterThan(0);
 
     // Remove the USD→ETB rate the seat-class formula multiplies by.
     await harness.prisma.currencyExchangeRate.deleteMany({
       where: { fromCurrency: "USD", toCurrency: "ETB" },
     });
 
-    const withoutRate = await fareEngine.calculate(baseDto() as any);
-
-    // Correct behavior would be to reject/flag; instead the fare silently drops by the rate factor.
-    expect(withoutRate.totalMinor).toBe(withRate.totalMinor / USD_TO_ETB);
-    expect(withoutRate.totalMinor).toBeLessThan(withRate.totalMinor);
+    await expect(fareEngine.calculate(baseDto() as any)).rejects.toThrow(/No exchange rate configured/i);
   });
 });
diff --git a/apps/edr-passenger-api/test/reserve-seat-issue-booking.e2e-spec.ts b/apps/edr-passenger-api/test/reserve-seat-issue-booking.e2e-spec.ts
new file mode 100644
index 000000000..cb347092a
--- /dev/null
+++ b/apps/edr-passenger-api/test/reserve-seat-issue-booking.e2e-spec.ts
@@ -0,0 +1,374 @@
+/**
+ * Reserve seat → release | issue booking — coverage for GuestBookingService.
+ * issueBookingFromReservation(), BookingsService.getByPayToken(), and the
+ * SeatsService.unblockSeat() reuse that releases the reservation.
+ *
+ * STAFF path: fee-waived, finalized immediately via PaymentsService.finalizePaymentSuccess()
+ * (the same all-in-one finalizer every real payment webhook uses) — proves a Ticket is
+ * issued, the booking is CONFIRMED, and the reservation's own SeatBlock is released (not
+ * left stale) before TicketsService.generate() marks the now-ticketed seat BOOKED with its
+ * own fresh block — the correct end state once a real ticket exists, distinct from an
+ * operational reservation that never converts into a booking.
+ *
+ * PASSENGER path: booking stays PENDING_PAYMENT with a payToken texted to the traveler —
+ * proves no PaymentIntent is created yet (the passenger creates one themselves later via the
+ * already-public /payments/initiate, same as a normal guest checkout) and that
+ * BookingsService.getByPayToken() resolves it for the portal's pay-by-link page.
+ *
+ * Uses the slim harness (real Nest DI) for SchedulesService/CurrencyService/FareEngineService,
+ * same as stop-based-booking-segment.e2e-spec.ts. SeatsService/TicketsService/PaymentsService/
+ * GuestBookingService/BookingsService are instantiated directly with a real Prisma +
+ * stubbed collaborators (Tier-2 pattern, money-integrity.e2e-spec.ts) — PaymentsModule/
+ * BookingsModule pull in NotificationsModule → RabbitMQ, which the slim harness avoids.
+ */
+import { IdDocumentType, PaymentIntentStatus, PaymentMethodType } from "@prisma/client";
+import { validateSync } from "class-validator";
+import { plainToInstance } from "class-transformer";
+import { SchedulesService } from "../src/modules/schedules/schedules.service";
+import { SeatsService } from "../src/modules/seats/seats.service";
+import { TicketsService } from "../src/modules/tickets/tickets.service";
+import { PaymentsService } from "../src/modules/payments/payments.service";
+import { CurrencyService } from "../src/modules/currency/currency.service";
+import { FareEngineService } from "../src/modules/fare-engine/fare-engine.service";
+import { SystemConfigService } from "../src/modules/system-config/system-config.service";
+import { BookingsService } from "../src/modules/bookings/bookings.service";
+import { GuestBookingService } from "../src/modules/bookings/guest-booking.service";
+import { ReservationBookingKind, IssueReservationBookingDto } from "../src/modules/bookings/guest-booking.dto";
+import { createServiceHarness, ServiceHarness } from "./setup/slim-app";
+import { IDS, resetAndSeedCore } from "./fixtures/seed-core";
+
+/** A Proxy whose every property is an async no-op — satisfies unused collaborator method calls. */
+function asyncStub(): any {
+  return new Proxy({}, { get: () => async () => undefined });
+}
+
+describe("Reserve seat — issue booking (STAFF / PASSENGER)", () => {
+  let harness: ServiceHarness;
+  let schedulesService: SchedulesService;
+  let seatsService: SeatsService;
+  let guestBookingService: GuestBookingService;
+  let bookingsService: BookingsService;
+  let smsClient: { sendSms: jest.Mock };
+
+  beforeAll(async () => {
+    harness = await createServiceHarness();
+    schedulesService = await harness.moduleRef.resolve(SchedulesService);
+    const currencyService = harness.moduleRef.get(CurrencyService);
+    const fareEngine = harness.moduleRef.get(FareEngineService);
+    const systemConfig = new SystemConfigService(harness.prisma as any);
+
+    seatsService = new SeatsService(harness.prisma as any, asyncStub(), systemConfig, asyncStub(), asyncStub());
+    const ticketsService = new TicketsService(harness.prisma as any, asyncStub(), systemConfig, asyncStub(), asyncStub());
+    const paymentsService = new PaymentsService(
+      harness.prisma as any,
+      seatsService,
+      ticketsService,
+      { emit: () => true } as any, // eventEmitter
+      asyncStub(), // paymentClient — never reached: finalizePaymentSuccess doesn't call it
+      currencyService,
+      asyncStub(), // auditService
+    );
+    smsClient = { sendSms: jest.fn().mockResolvedValue({ queued: true }) };
+    guestBookingService = new GuestBookingService(
+      harness.prisma as any,
+      seatsService,
+      asyncStub(), // verifaydaService — never reached: test passengers use PASSPORT, not NATIONAL_ID
+      currencyService,
+      asyncStub(), // passengerAuthService — never reached: no createAccount in this flow
+      fareEngine,
+      { emit: () => true } as any, // eventEmitter
+      paymentsService,
+      asyncStub(), // auditService
+      smsClient,
+    );
+    bookingsService = new BookingsService(
+      harness.prisma as any,
+      asyncStub(), // dataSource
+      seatsService,
+      { emit: () => true } as any,
+      asyncStub(), // verifaydaService
+      currencyService,
+      fareEngine,
+      asyncStub(), // auditService
+    );
+  });
+
+  afterAll(async () => {
+    await harness?.close();
+  });
+
+  beforeEach(() => {
+    smsClient.sendSms.mockClear();
+  });
+
+  /** Creates a fresh Train + TrainSchedule on the seed-core route, coach assigned at creation. */
+  async function createTestSchedule(opts: { trainNumber: string; departureAt: Date; arrivalAt: Date }) {
+    const train = await harness.prisma.train.create({
+      data: { number: opts.trainNumber, name: `Test ${opts.trainNumber}` },
+    });
+    const coach = await harness.prisma.coach.create({
+      data: { coachTypeId: IDS.coachType, number: `${opts.trainNumber}-C1`, capacity: 4, sequence: 1, status: "ACTIVE" },
+    });
+    const seats = await Promise.all(
+      ["1A", "1B"].map((seatNumber, i) =>
+        harness.prisma.seat.create({
+          data: { coachId: coach.id, seatNumber, row: 1, col: seatNumber.slice(-1), isWindow: i === 0, isAisle: i === 1 },
+        }),
+      ),
+    );
+    const schedule = await schedulesService.createSchedule({
+      trainId: train.id,
+      routeId: IDS.route,
+      departureAt: opts.departureAt.toISOString(),
+      arrivalAt: opts.arrivalAt.toISOString(),
+      coachIds: [coach.id],
+    } as any);
+    return { schedule, seats };
+  }
+
+  function baseDto(overrides: Partial<Record<string, any>> = {}) {
+    return {
+      scheduleId: "", // filled per-test
+      originStationId: IDS.stationA,
+      destinationStationId: IDS.stationB,
+      // No seatClassId — the seat's class is resolved server-side from its coach type +
+      // nationality tier (Djiboutian -> LOCAL, matching seed-core's seatClassLocal).
+      bookingKind: ReservationBookingKind.STAFF,
+      passengerName: "Test Traveler",
+      dateOfBirth: "1990-01-01",
+      idDocumentType: IdDocumentType.PASSPORT,
+      passportNumber: "X123456",
+      nationality: "Djiboutian",
+      ...overrides,
+    };
+  }
+
+  it("404s when the seat has no active reservation", async () => {
+    await resetAndSeedCore(harness.prisma);
+    const dep = new Date(Date.now() + 3 * 60 * 60_000);
+    const arr = new Date(dep.getTime() + 100 * 60_000);
+    const { schedule, seats } = await createTestSchedule({ trainNumber: `RES-404-${Date.now()}`, departureAt: dep, arrivalAt: arr });
+
+    await expect(
+      guestBookingService.issueBookingFromReservation(
+        seats[0].id,
+        baseDto({ scheduleId: schedule.id }) as any,
+        null,
+      ),
+    ).rejects.toThrow(/not reserved/i);
+  });
+
+  it("resolves the seat class (and therefore fare) from nationality — LOCAL for Ethiopian/Djiboutian, INTERNATIONAL for Other", async () => {
+    await resetAndSeedCore(harness.prisma);
+    const dep = new Date(Date.now() + 3 * 60 * 60_000);
+    const arr = new Date(dep.getTime() + 100 * 60_000);
+
+    // A->B is 100km (seed-core DISTANCE). LOCAL seatClass is 3.00 ETB/km, INTERNATIONAL is
+    // 5.00 ETB/km, USD_TO_ETB=100 — same formula pricing-fare-engine.e2e-spec.ts verifies.
+    // Both use PASSENGER kind so the computed fare survives unwaived (STAFF always zeroes
+    // totalMinor/fareMinor regardless of the resolved seat class).
+    const localSchedule = await createTestSchedule({ trainNumber: `RES-FARE-LOCAL-${Date.now()}`, departureAt: dep, arrivalAt: arr });
+    await seatsService.blockSeat(localSchedule.seats[0].id, "Reserved", localSchedule.schedule.id);
+    const localBooking: any = await guestBookingService.issueBookingFromReservation(
+      localSchedule.seats[0].id,
+      baseDto({ scheduleId: localSchedule.schedule.id, bookingKind: ReservationBookingKind.PASSENGER, phone: "+251911234567", nationality: "Ethiopian" }) as any,
+      null,
+    );
+    const localSeat = await harness.prisma.bookingSeat.findFirst({ where: { bookingId: localBooking.booking.id } });
+    expect(localSeat?.fareMinor).toBe(30_000);
+
+    const intlSchedule = await createTestSchedule({ trainNumber: `RES-FARE-INTL-${Date.now()}`, departureAt: dep, arrivalAt: arr });
+    await seatsService.blockSeat(intlSchedule.seats[0].id, "Reserved", intlSchedule.schedule.id);
+    const intlBooking: any = await guestBookingService.issueBookingFromReservation(
+      intlSchedule.seats[0].id,
+      baseDto({ scheduleId: intlSchedule.schedule.id, bookingKind: ReservationBookingKind.PASSENGER, phone: "+253771234567", nationality: "Other" }) as any,
+      null,
+    );
+    expect(intlBooking.booking.totalMinor).toBe(50_000);
+  });
+
+  it("rejects a nationality outside Ethiopian/Djiboutian/Other at the DTO level", () => {
+    const dto = plainToInstance(IssueReservationBookingDto, baseDto({ scheduleId: "irrelevant", nationality: "French" }));
+    const errors = validateSync(dto);
+    expect(errors.some((e) => e.property === "nationality")).toBe(true);
+  });
+
+  it("STAFF + a GLOBAL block: booking is CONFIRMED, fee-waived, ticket issued, and the old global block is replaced (not left stale)", async () => {
+    await resetAndSeedCore(harness.prisma);
+    const dep = new Date(Date.now() + 3 * 60 * 60_000);
+    const arr = new Date(dep.getTime() + 100 * 60_000);
+    const { schedule, seats } = await createTestSchedule({ trainNumber: `RES-STAFF-GLOBAL-${Date.now()}`, departureAt: dep, arrivalAt: arr });
+
+    await seatsService.blockSeat(seats[0].id, "VIP hold — mayor's office");
+
+    const result: any = await guestBookingService.issueBookingFromReservation(
+      seats[0].id,
+      baseDto({ scheduleId: schedule.id, bookingKind: ReservationBookingKind.STAFF }) as any,
+      "staff-user-1",
+    );
+
+    expect(result.booking.status).toBe("CONFIRMED");
+    expect(result.payUrl).toBeUndefined();
+
+    const intent = await harness.prisma.paymentIntent.findUnique({ where: { bookingId: result.booking.id } });
+    expect(intent?.amountMinor).toBe(0);
+    expect(intent?.status).toBe(PaymentIntentStatus.SUCCEEDED);
+    expect(intent?.method).toBe(PaymentMethodType.WALLET);
+
+    const ticketCount = await harness.prisma.ticket.count({ where: { bookingId: result.booking.id } });
+    expect(ticketCount).toBeGreaterThan(0);
+
+    // TicketsService.generate() itself creates a fresh global SeatBlock ("Booked in
+    // tickets ...") once a ticket is actually issued — a ticketed seat SHOULD show as
+    // unavailable. The meaningful assertion is that the ORIGINAL reservation's block is
+    // gone (proving unblockSeat ran), replaced by exactly this one new booked-marker block —
+    // not that the seat is left globally BLOCKED under the old reservation's reason forever.
+    const blocks = await harness.prisma.seatBlock.findMany({ where: { seatId: seats[0].id } });
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].reason).not.toMatch(/VIP hold/);
+    expect(blocks[0].reason).toMatch(/Booked in tickets/);
+
+    const seat = await harness.prisma.seat.findUnique({ where: { id: seats[0].id } });
+    expect(seat?.status).toBe("BOOKED");
+  });
+
+  it("STAFF + a SCHEDULE-SCOPED block: same release path, no leftover reservation block", async () => {
+    await resetAndSeedCore(harness.prisma);
+    const dep = new Date(Date.now() + 3 * 60 * 60_000);
+    const arr = new Date(dep.getTime() + 100 * 60_000);
+    const { schedule, seats } = await createTestSchedule({ trainNumber: `RES-STAFF-SCOPED-${Date.now()}`, departureAt: dep, arrivalAt: arr });
+
+    await seatsService.blockSeat(seats[0].id, "Reserved for inspection", schedule.id);
+    const seatBefore = await harness.prisma.seat.findUnique({ where: { id: seats[0].id } });
+    expect(seatBefore?.status).not.toBe("BLOCKED"); // schedule-scoped block never touches Seat.status
+
+    const result: any = await guestBookingService.issueBookingFromReservation(
+      seats[0].id,
+      baseDto({ scheduleId: schedule.id, bookingKind: ReservationBookingKind.STAFF }) as any,
+      "staff-user-2",
+    );
+
+    expect(result.booking.status).toBe("CONFIRMED");
+    // The original schedule-scoped reservation block is gone; only generate()'s own
+    // booked-marker block remains (see the global-block test above for why).
+    const originalScopedBlock = await harness.prisma.seatBlock.count({
+      where: { seatId: seats[0].id, scheduleId: schedule.id, reason: "Reserved for inspection" },
+    });
+    expect(originalScopedBlock).toBe(0);
+
+    // Same as the global-block test — generate() marks the now-ticketed seat BOOKED.
+    const seatAfter = await harness.prisma.seat.findUnique({ where: { id: seats[0].id } });
+    expect(seatAfter?.status).toBe("BOOKED");
+  });
+
+  it("PASSENGER path: booking stays PENDING_PAYMENT, payToken is set, no PaymentIntent yet, SMS sent with the pay link", async () => {
+    await resetAndSeedCore(harness.prisma);
+    const dep = new Date(Date.now() + 3 * 60 * 60_000);
+    const arr = new Date(dep.getTime() + 100 * 60_000);
+    const { schedule, seats } = await createTestSchedule({ trainNumber: `RES-PAX-${Date.now()}`, departureAt: dep, arrivalAt: arr });
+
+    await seatsService.blockSeat(seats[0].id, "Reserved pending payment", schedule.id);
+
+    const result: any = await guestBookingService.issueBookingFromReservation(
+      seats[0].id,
+      baseDto({ scheduleId: schedule.id, bookingKind: ReservationBookingKind.PASSENGER, phone: "+253771234567" }) as any,
+      "staff-user-3",
+    );
+
+    expect(result.booking.status).toBe("PENDING_PAYMENT");
+    expect(result.booking.payToken).toBeTruthy();
+    expect(result.payUrl).toContain(result.booking.payToken);
+
+    const intent = await harness.prisma.paymentIntent.findUnique({ where: { bookingId: result.booking.id } });
+    expect(intent).toBeNull();
+
+    expect(smsClient.sendSms).toHaveBeenCalledTimes(1);
+    const smsArgs = smsClient.sendSms.mock.calls[0][0];
+    expect(smsArgs.to).toBe("+253771234567");
+    expect(smsArgs.message).toContain(result.booking.payToken);
+
+    // BookingsService.getByPayToken — the portal pay-by-link page's data source.
+    const byToken: any = await bookingsService.getByPayToken(result.booking.payToken);
+    expect(byToken.id).toBe(result.booking.id);
+    expect(byToken.status).toBe("PENDING_PAYMENT");
+    expect(byToken.schedule.origin.id).toBe(IDS.stationA);
+  });
+
+  it("requires a phone number for a PASSENGER booking", async () => {
+    await resetAndSeedCore(harness.prisma);
+    const dep = new Date(Date.now() + 3 * 60 * 60_000);
+    const arr = new Date(dep.getTime() + 100 * 60_000);
+    const { schedule, seats } = await createTestSchedule({ trainNumber: `RES-PAX-NOPHONE-${Date.now()}`, departureAt: dep, arrivalAt: arr });
+
+    await seatsService.blockSeat(seats[0].id, "Reserved", schedule.id);
+
+    await expect(
+      guestBookingService.issueBookingFromReservation(
+        seats[0].id,
+        baseDto({ scheduleId: schedule.id, bookingKind: ReservationBookingKind.PASSENGER, phone: undefined }) as any,
+        null,
+      ),
+    ).rejects.toThrow(/phone number is required/i);
+  });
+
+  it("rejects NATIONAL_ID for a non-Ethiopian nationality", async () => {
+    await resetAndSeedCore(harness.prisma);
+    const dep = new Date(Date.now() + 3 * 60 * 60_000);
+    const arr = new Date(dep.getTime() + 100 * 60_000);
+    const { schedule, seats } = await createTestSchedule({ trainNumber: `RES-NATID-${Date.now()}`, departureAt: dep, arrivalAt: arr });
+
+    await seatsService.blockSeat(seats[0].id, "Reserved", schedule.id);
+
+    await expect(
+      guestBookingService.issueBookingFromReservation(
+        seats[0].id,
+        baseDto({
+          scheduleId: schedule.id,
+          nationality: "Djiboutian",
+          idDocumentType: IdDocumentType.NATIONAL_ID,
+          idDocumentNumber: "ET123456789",
+        }) as any,
+        null,
+      ),
+    ).rejects.toThrow(/national id is only valid for ethiopian/i);
+  });
+
+  it("still enforces the check-in cutoff — rejects once the boarding stop is too close to departure", async () => {
+    await resetAndSeedCore(harness.prisma);
+    const dep = new Date(Date.now() + 5 * 60_000); // 5min out — inside the default 30-min cutoff
+    const arr = new Date(dep.getTime() + 50 * 60_000);
+    const { schedule, seats } = await createTestSchedule({ trainNumber: `RES-CUTOFF-${Date.now()}`, departureAt: dep, arrivalAt: arr });
+
+    await seatsService.blockSeat(seats[0].id, "Reserved", schedule.id);
+
+    await expect(
+      guestBookingService.issueBookingFromReservation(
+        seats[0].id,
+        baseDto({ scheduleId: schedule.id, originStationId: IDS.stationA, destinationStationId: IDS.stationB }) as any,
+        null,
+      ),
+    ).rejects.toThrow(/not accepted within/i);
+  });
+
+  it("getByPayToken 404s for an unknown token and 400s once expired", async () => {
+    await resetAndSeedCore(harness.prisma);
+    await expect(bookingsService.getByPayToken("no-such-token")).rejects.toThrow(/not found/i);
+
+    const dep = new Date(Date.now() + 3 * 60 * 60_000);
+    const arr = new Date(dep.getTime() + 100 * 60_000);
+    const { schedule, seats } = await createTestSchedule({ trainNumber: `RES-EXPIRED-${Date.now()}`, departureAt: dep, arrivalAt: arr });
+    await seatsService.blockSeat(seats[0].id, "Reserved", schedule.id);
+    const result: any = await guestBookingService.issueBookingFromReservation(
+      seats[0].id,
+      baseDto({ scheduleId: schedule.id, bookingKind: ReservationBookingKind.PASSENGER, phone: "+253771234567" }) as any,
+      null,
+    );
+
+    await harness.prisma.booking.update({
+      where: { id: result.booking.id },
+      data: { payTokenExpiresAt: new Date(Date.now() - 60_000) },
+    });
+
+    await expect(bookingsService.getByPayToken(result.booking.payToken)).rejects.toThrow(/expired/i);
+  });
+});
diff --git a/apps/edr-passenger-api/test/schedule-lifecycle.e2e-spec.ts b/apps/edr-passenger-api/test/schedule-lifecycle.e2e-spec.ts
new file mode 100644
index 000000000..d76090ab3
--- /dev/null
+++ b/apps/edr-passenger-api/test/schedule-lifecycle.e2e-spec.ts
@@ -0,0 +1,206 @@
+/**
+ * Schedule lifecycle coverage — bulkGenerateSchedules, createSchedule's "must have at least
+ * one coach assigned" guard (added recently — the exact validation whose ordering broke
+ * checkin-cutoff.e2e-spec.ts's fixture helper earlier this session), and
+ * TasksService.syncScheduleStatuses' full schedule-level state machine
+ * (SCHEDULED -> BOARDING -> EN_ROUTE -> ARRIVED). checkin-cutoff.e2e-spec.ts already covers
+ * the per-stop CHECKIN_CLOSED/OPEN half of syncScheduleStatuses — not repeated here.
+ */
+import { SchedulesService } from "../src/modules/schedules/schedules.service";
+import { TasksService } from "../src/modules/tasks/tasks.service";
+import { createServiceHarness, ServiceHarness } from "./setup/slim-app";
+import { IDS, resetAndSeedCore } from "./fixtures/seed-core";
+
+function asyncStub(): any {
+  return new Proxy({}, { get: () => async () => undefined });
+}
+
+describe("Schedule lifecycle — bulk generate, coach guard, status transitions", () => {
+  let harness: ServiceHarness;
+  let schedulesService: SchedulesService;
+  let tasksService: TasksService;
+
+  beforeAll(async () => {
+    harness = await createServiceHarness();
+    schedulesService = await harness.moduleRef.resolve(SchedulesService);
+    tasksService = new TasksService(harness.prisma as any, asyncStub(), asyncStub());
+  });
+
+  afterAll(async () => {
+    await harness?.close();
+  });
+
+  beforeEach(async () => {
+    await resetAndSeedCore(harness.prisma);
+  });
+
+  const future = (mins: number) => new Date(Date.now() + mins * 60_000);
+
+  async function createCoach(trainNumber: string) {
+    return harness.prisma.coach.create({
+      data: { coachTypeId: IDS.coachType, number: `${trainNumber}-C1`, capacity: 4, sequence: 1, status: "ACTIVE" },
+    });
+  }
+
+  describe("createSchedule coach-assignment guard", () => {
+    it("rejects a schedule with no coachIds and no route coach template", async () => {
+      const train = await harness.prisma.train.create({ data: { number: `SCH-NOCOACH-${Date.now()}`, name: "Test" } });
+
+      await expect(
+        schedulesService.createSchedule({
+          trainId: train.id,
+          routeId: IDS.route,
+          departureAt: future(180).toISOString(),
+          arrivalAt: future(280).toISOString(),
+        } as any),
+      ).rejects.toThrow(/must have at least one coach assigned/i);
+
+      const orphan = await harness.prisma.trainSchedule.findFirst({ where: { trainId: train.id } });
+      expect(orphan).toBeNull(); // no dead schedule left behind
+    });
+
+    it("auto-applies the route's coach template when coachIds are omitted", async () => {
+      const train = await harness.prisma.train.create({ data: { number: `SCH-TEMPLATE-${Date.now()}`, name: "Test" } });
+      const coach = await createCoach(train.number);
+      await harness.prisma.routeCoachTemplate.create({
+        data: { routeId: IDS.route, coachId: coach.id, positionNumber: 1 },
+      });
+
+      const schedule = await schedulesService.createSchedule({
+        trainId: train.id,
+        routeId: IDS.route,
+        departureAt: future(180).toISOString(),
+        arrivalAt: future(280).toISOString(),
+      } as any);
+
+      const assignments = await harness.prisma.coachAssignment.findMany({ where: { scheduleId: schedule.id } });
+      expect(assignments).toHaveLength(1);
+      expect(assignments[0].coachId).toBe(coach.id);
+    });
+
+    it("explicit coachIds override the route's coach template", async () => {
+      const train = await harness.prisma.train.create({ data: { number: `SCH-OVERRIDE-${Date.now()}`, name: "Test" } });
+      const templateCoach = await createCoach(`${train.number}-tmpl`);
+      const explicitCoach = await createCoach(`${train.number}-explicit`);
+      await harness.prisma.routeCoachTemplate.create({
+        data: { routeId: IDS.route, coachId: templateCoach.id, positionNumber: 1 },
+      });
+
+      const schedule = await schedulesService.createSchedule({
+        trainId: train.id,
+        routeId: IDS.route,
+        departureAt: future(180).toISOString(),
+        arrivalAt: future(280).toISOString(),
+        coachIds: [explicitCoach.id],
+      } as any);
+
+      const assignments = await harness.prisma.coachAssignment.findMany({ where: { scheduleId: schedule.id } });
+      expect(assignments).toHaveLength(1);
+      expect(assignments[0].coachId).toBe(explicitCoach.id);
+    });
+  });
+
+  describe("bulkGenerateSchedules", () => {
+    it("generates one schedule per repeat interval across the date range", async () => {
+      const train = await harness.prisma.train.create({ data: { number: `BULK-${Date.now()}`, name: "Test" } });
+      const coach = await createCoach(train.number);
+      await harness.prisma.routeCoachTemplate.create({ data: { routeId: IDS.route, coachId: coach.id, positionNumber: 1 } });
+
+      const start = future(2 * 24 * 60); // 2 days out, clear of "today" edge cases
+      const result = await schedulesService.bulkGenerateSchedules({
+        trainId: train.id,
+        routeId: IDS.route,
+        startDateTime: start.toISOString(),
+        forNextDays: 5,
+        repeatEveryDays: 2,
+        durationHours: 3,
+      } as any);
+
+      // while(currentDate < endDate) stepping by 2 days over a 5-day window: day 0, 2, 4.
+      expect(result.schedulesCreated).toBe(3);
+      expect(result.errors).toHaveLength(0);
+      expect(result.scheduleIds).toHaveLength(3);
+
+      const schedules = await harness.prisma.trainSchedule.findMany({ where: { trainId: train.id }, orderBy: { departureAt: "asc" } });
+      expect(schedules).toHaveLength(3);
+      const daysBetween = (a: Date, b: Date) => Math.round((b.getTime() - a.getTime()) / (24 * 60 * 60 * 1000));
+      expect(daysBetween(schedules[0].departureAt, schedules[1].departureAt)).toBe(2);
+      expect(daysBetween(schedules[1].departureAt, schedules[2].departureAt)).toBe(2);
+    });
+
+    it("collects per-day errors without aborting the rest of the run", async () => {
+      const train = await harness.prisma.train.create({ data: { number: `BULK-ERR-${Date.now()}`, name: "Test" } });
+      const coach = await createCoach(train.number);
+      await harness.prisma.routeCoachTemplate.create({ data: { routeId: IDS.route, coachId: coach.id, positionNumber: 1 } });
+
+      const start = future(2 * 24 * 60);
+      const dto = {
+        trainId: train.id,
+        routeId: IDS.route,
+        startDateTime: start.toISOString(),
+        forNextDays: 4,
+        repeatEveryDays: 1,
+        durationHours: 3,
+      } as any;
+
+      const first = await schedulesService.bulkGenerateSchedules(dto);
+      expect(first.schedulesCreated).toBe(4);
+      expect(first.errors).toHaveLength(0);
+
+      // Re-running the exact same range collides with EVERY day just created (same
+      // train+route+date already exists) — proves errors are collected per-day, not thrown,
+      // and the count/errors array accurately reflect zero successes this time.
+      const second = await schedulesService.bulkGenerateSchedules(dto);
+      expect(second.schedulesCreated).toBe(0);
+      expect(second.errors).toHaveLength(4);
+      expect(second.errors[0]).toMatch(/already exists/i);
+    });
+  });
+
+  describe("syncScheduleStatuses — schedule-level state machine", () => {
+    async function scheduleWithCoach(trainNumber: string, departureAt: Date, arrivalAt: Date) {
+      const train = await harness.prisma.train.create({ data: { number: trainNumber, name: "Test" } });
+      const coach = await createCoach(trainNumber);
+      return schedulesService.createSchedule({
+        trainId: train.id,
+        routeId: IDS.route,
+        departureAt: departureAt.toISOString(),
+        arrivalAt: arrivalAt.toISOString(),
+        coachIds: [coach.id],
+      } as any);
+    }
+
+    it("SCHEDULED -> BOARDING once within the 30-min cutoff window", async () => {
+      const schedule = await scheduleWithCoach(`SYNC-BOARD-${Date.now()}`, future(20), future(80));
+      expect((await harness.prisma.trainSchedule.findUnique({ where: { id: schedule.id } }))?.status).toBe("SCHEDULED");
+
+      await tasksService.syncScheduleStatuses();
+
+      expect((await harness.prisma.trainSchedule.findUnique({ where: { id: schedule.id } }))?.status).toBe("BOARDING");
+    });
+
+    it("BOARDING -> EN_ROUTE once departure has passed", async () => {
+      const schedule = await scheduleWithCoach(`SYNC-ENROUTE-${Date.now()}`, future(20), future(80));
+      await tasksService.syncScheduleStatuses();
+      await harness.prisma.trainSchedule.update({ where: { id: schedule.id }, data: { departureAt: new Date(Date.now() - 60_000) } });
+
+      await tasksService.syncScheduleStatuses();
+
+      expect((await harness.prisma.trainSchedule.findUnique({ where: { id: schedule.id } }))?.status).toBe("EN_ROUTE");
+    });
+
+    it("EN_ROUTE -> ARRIVED once arrival has passed", async () => {
+      const schedule = await scheduleWithCoach(`SYNC-ARRIVED-${Date.now()}`, future(20), future(80));
+      await tasksService.syncScheduleStatuses();
+      await harness.prisma.trainSchedule.update({
+        where: { id: schedule.id },
+        data: { departureAt: new Date(Date.now() - 120_000), arrivalAt: new Date(Date.now() - 60_000) },
+      });
+
+      await tasksService.syncScheduleStatuses();
+      await tasksService.syncScheduleStatuses(); // BOARDING->EN_ROUTE and EN_ROUTE->ARRIVED are separate updateMany calls in one pass — one call suffices, second call is a no-op idempotency check
+
+      expect((await harness.prisma.trainSchedule.findUnique({ where: { id: schedule.id } }))?.status).toBe("ARRIVED");
+    });
+  });
+});
diff --git a/apps/edr-passenger-api/test/stop-based-booking-segment.e2e-spec.ts b/apps/edr-passenger-api/test/stop-based-booking-segment.e2e-spec.ts
index dfcc298fd..7fcce106b 100644
--- a/apps/edr-passenger-api/test/stop-based-booking-segment.e2e-spec.ts
+++ b/apps/edr-passenger-api/test/stop-based-booking-segment.e2e-spec.ts
@@ -95,6 +95,9 @@ describe("Stop-based booking — segment time & cutoff correctness", () => {
       asyncStub(), // passengerAuthService — never reached: no createAccount in these DTOs
       fareEngine,
       { emit: () => true } as any, // eventEmitter
+      asyncStub(), // paymentsService — never reached: these tests use createGuestBooking, not issueBookingFromReservation
+      asyncStub(), // auditService
+      asyncStub(), // smsClient
     );
   });
 
diff --git a/apps/edr-passenger-api/test/ticketing.e2e-spec.ts b/apps/edr-passenger-api/test/ticketing.e2e-spec.ts
new file mode 100644
index 000000000..b8a380577
--- /dev/null
+++ b/apps/edr-passenger-api/test/ticketing.e2e-spec.ts
@@ -0,0 +1,282 @@
+/**
+ * Ticketing/boarding coverage — TicketsService.generate()/scanAndBoard()/validate() and the
+ * smart-seat-reassignment fallback, none of which had any e2e coverage before this suite
+ * (colocated tickets.service.spec.ts only covers offline batch validation, a different path).
+ *
+ * IMPORTANT: scanAndBoard() catches every internal error and returns
+ * `{ success: false, error, errorCode }` rather than throwing — assertions against it check
+ * the return value, not `.rejects.toThrow()`.
+ *
+ * Same Tier-2 direct-instantiation pattern as reserve-seat-issue-booking.e2e-spec.ts /
+ * booking-types.e2e-spec.ts.
+ */
+import { IdDocumentType, PaymentIntentStatus, PaymentMethodType } from "@prisma/client";
+import { SchedulesService } from "../src/modules/schedules/schedules.service";
+import { SeatsService } from "../src/modules/seats/seats.service";
+import { TicketsService } from "../src/modules/tickets/tickets.service";
+import { CurrencyService } from "../src/modules/currency/currency.service";
+import { FareEngineService } from "../src/modules/fare-engine/fare-engine.service";
+import { SystemConfigService } from "../src/modules/system-config/system-config.service";
+import { GuestBookingService } from "../src/modules/bookings/guest-booking.service";
+import { createServiceHarness, ServiceHarness } from "./setup/slim-app";
+import { IDS, resetAndSeedCore } from "./fixtures/seed-core";
+
+function asyncStub(): any {
+  return new Proxy({}, { get: () => async () => undefined });
+}
+
+describe("Ticketing — generate / scanAndBoard / validate / smart-reassign", () => {
+  let harness: ServiceHarness;
+  let schedulesService: SchedulesService;
+  let seatsService: SeatsService;
+  let ticketsService: TicketsService;
+  let guestBookingService: GuestBookingService;
+
+  beforeAll(async () => {
+    harness = await createServiceHarness();
+    schedulesService = await harness.moduleRef.resolve(SchedulesService);
+    const currencyService = harness.moduleRef.get(CurrencyService);
+    const fareEngine = harness.moduleRef.get(FareEngineService);
+    const systemConfig = new SystemConfigService(harness.prisma as any);
+
+    seatsService = new SeatsService(harness.prisma as any, asyncStub(), systemConfig, asyncStub(), asyncStub());
+    ticketsService = new TicketsService(harness.prisma as any, asyncStub(), systemConfig, asyncStub(), asyncStub());
+    guestBookingService = new GuestBookingService(
+      harness.prisma as any,
+      seatsService,
+      asyncStub(),
+      currencyService,
+      asyncStub(),
+      fareEngine,
+      { emit: () => true } as any,
+      asyncStub(), // paymentsService — not used; tests drive generate()/scanAndBoard() directly
+      asyncStub(),
+      asyncStub(),
+    );
+  });
+
+  afterAll(async () => {
+    await harness?.close();
+  });
+
+  beforeEach(async () => {
+    await resetAndSeedCore(harness.prisma);
+  });
+
+  async function createTestSchedule(opts: { trainNumber: string; departureAt: Date; arrivalAt: Date; seatCount?: number }) {
+    const train = await harness.prisma.train.create({
+      data: { number: opts.trainNumber, name: `Test ${opts.trainNumber}` },
+    });
+    const coach = await harness.prisma.coach.create({
+      data: { coachTypeId: IDS.coachType, number: `${opts.trainNumber}-C1`, capacity: opts.seatCount ?? 4, sequence: 1, status: "ACTIVE" },
+    });
+    const seatCount = opts.seatCount ?? 4;
+    const seatNumbers = Array.from({ length: seatCount }, (_, i) => `1${String.fromCharCode(65 + i)}`);
+    const seats = await Promise.all(
+      seatNumbers.map((seatNumber, i) =>
+        harness.prisma.seat.create({
+          data: { coachId: coach.id, seatNumber, row: 1, col: seatNumber.slice(-1), isWindow: i === 0, isAisle: i === 1 },
+        }),
+      ),
+    );
+    const schedule = await schedulesService.createSchedule({
+      trainId: train.id,
+      routeId: IDS.route,
+      departureAt: opts.departureAt.toISOString(),
+      arrivalAt: opts.arrivalAt.toISOString(),
+      coachIds: [coach.id],
+    } as any);
+    return { schedule, seats };
+  }
+
+  function passengerDto(seatId: string, overrides: Partial<Record<string, any>> = {}) {
+    return {
+      seatId,
+      passengerName: "Test Traveler",
+      dateOfBirth: "1990-01-01",
+      idDocumentType: IdDocumentType.PASSPORT,
+      passportNumber: "X123456",
+      passportCountry: "Djibouti",
+      nationality: "Djiboutian",
+      ...overrides,
+    };
+  }
+
+  const future = (mins: number) => new Date(Date.now() + mins * 60_000);
+
+  /** Creates a real PENDING_PAYMENT ONE_WAY booking via the guest flow. */
+  async function createOneWayBooking(scheduleId: string, seatId: string, originStationId = IDS.stationA, destinationStationId = IDS.stationB) {
+    const hold = await seatsService.holdSeats({
+      scheduleId,
+      originStationId,
+      destinationStationId,
+      passengers: [{ passengerId: "55555555-5555-4555-8555-500000000001", seatId }],
+    } as any);
+    return guestBookingService.createGuestBooking({
+      scheduleId,
+      holdId: (hold as any).holdId,
+      originStationId,
+      destinationStationId,
+      seatClassId: IDS.seatClassLocal,
+      passengers: [passengerDto(seatId)],
+    } as any) as Promise<any>;
+  }
+
+  async function markSucceeded(bookingId: string) {
+    await harness.prisma.paymentIntent.create({
+      data: { bookingId, amountMinor: 30_000, currency: "ETB", method: PaymentMethodType.CARD, status: PaymentIntentStatus.SUCCEEDED, paidAt: new Date() },
+    });
+    await harness.prisma.booking.update({ where: { id: bookingId }, data: { status: "CONFIRMED" } });
+  }
+
+  describe("generate()", () => {
+    it("issues a ticket for a CONFIRMED booking with a SUCCEEDED PaymentIntent, and marks the seat BOOKED", async () => {
+      const { schedule, seats } = await createTestSchedule({ trainNumber: `TIX-GEN-${Date.now()}`, departureAt: future(180), arrivalAt: future(220) });
+      const booking = await createOneWayBooking(schedule.id, seats[0].id);
+      await markSucceeded(booking.id);
+
+      const result = await ticketsService.generate(booking.id);
+      expect(result.totalTickets).toBe(1);
+
+      const ticket = await harness.prisma.ticket.findFirst({ where: { bookingId: booking.id } });
+      expect(ticket).toBeTruthy();
+      expect(ticket?.qrPayload).toBeTruthy();
+      expect(ticket?.barcodePayload).toBeTruthy();
+
+      const seat = await harness.prisma.seat.findUnique({ where: { id: seats[0].id } });
+      expect(seat?.status).toBe("BOOKED");
+    });
+
+    it("rejects with 'Payment not completed' when there's no PaymentIntent at all", async () => {
+      const { schedule, seats } = await createTestSchedule({ trainNumber: `TIX-NOPI-${Date.now()}`, departureAt: future(180), arrivalAt: future(220) });
+      const booking = await createOneWayBooking(schedule.id, seats[0].id);
+
+      await expect(ticketsService.generate(booking.id)).rejects.toThrow(/Payment not completed/i);
+    });
+
+    it("rejects with 'Payment not completed' when the PaymentIntent hasn't succeeded", async () => {
+      const { schedule, seats } = await createTestSchedule({ trainNumber: `TIX-PENDING-${Date.now()}`, departureAt: future(180), arrivalAt: future(220) });
+      const booking = await createOneWayBooking(schedule.id, seats[0].id);
+      await harness.prisma.paymentIntent.create({
+        data: { bookingId: booking.id, amountMinor: 30_000, currency: "ETB", method: PaymentMethodType.CARD, status: PaymentIntentStatus.PROCESSING },
+      });
+
+      await expect(ticketsService.generate(booking.id)).rejects.toThrow(/Payment not completed/i);
+    });
+
+    it("auto-confirms a PENDING_PAYMENT booking whose PaymentIntent already SUCCEEDED (missed webhook)", async () => {
+      const { schedule, seats } = await createTestSchedule({ trainNumber: `TIX-HEAL-${Date.now()}`, departureAt: future(180), arrivalAt: future(220) });
+      const booking = await createOneWayBooking(schedule.id, seats[0].id);
+      expect(booking.status).toBe("PENDING_PAYMENT");
+      await harness.prisma.paymentIntent.create({
+        data: { bookingId: booking.id, amountMinor: 30_000, currency: "ETB", method: PaymentMethodType.CARD, status: PaymentIntentStatus.SUCCEEDED, paidAt: new Date() },
+      });
+
+      await ticketsService.generate(booking.id);
+
+      const refreshed = await harness.prisma.booking.findUnique({ where: { id: booking.id } });
+      expect(refreshed?.status).toBe("CONFIRMED");
+    });
+  });
+
+  describe("smart seat reassignment", () => {
+    it("generate() throws ConflictException on a genuinely overlapping confirmed seat; smartAssignAndGenerate() recovers onto a free seat", async () => {
+      const { schedule, seats } = await createTestSchedule({ trainNumber: `TIX-CONFLICT-${Date.now()}`, departureAt: future(180), arrivalAt: future(220), seatCount: 3 });
+
+      // Booking A already CONFIRMED on seats[0], full A->B route (matches the schedule's own
+      // origin/destination, guaranteeing segment overlap with anything else on seats[0]).
+      const passengerA = await harness.prisma.passenger.create({ data: {} });
+      const bookingA = await harness.prisma.booking.create({
+        data: {
+          bookingRef: `CONFA${Date.now()}`, passengerId: passengerA.id, scheduleId: schedule.id,
+          originStationId: IDS.stationA, destinationStationId: IDS.stationB,
+          status: "CONFIRMED", totalMinor: 30_000, displayCurrency: "ETB",
+          seats: { create: [{ seatId: seats[0].id, scheduleId: schedule.id, passengerName: "Passenger A", passengerCategory: "ADULT", fareMinor: 30_000, displayCurrency: "ETB" }] },
+        },
+      });
+      void bookingA;
+
+      // Booking B independently references the SAME seat (simulating however the conflict
+      // arose — the point of this test is the recovery path, not the cause).
+      const bookingB = await createOneWayBooking(schedule.id, seats[0].id);
+      await markSucceeded(bookingB.id);
+
+      await expect(ticketsService.generate(bookingB.id)).rejects.toThrow(/already confirmed for another booking/i);
+
+      const recovered = await ticketsService.smartAssignAndGenerate(bookingB.id);
+      expect(recovered.totalTickets).toBe(1);
+
+      const bookingSeat = await harness.prisma.bookingSeat.findFirst({ where: { bookingId: bookingB.id } });
+      expect(bookingSeat?.seatId).not.toBe(seats[0].id); // reassigned off the conflicting seat
+      expect([seats[1].id, seats[2].id]).toContain(bookingSeat?.seatId);
+
+      const ticket = await harness.prisma.ticket.findFirst({ where: { bookingId: bookingB.id } });
+      expect(ticket?.seatId).toBe(bookingSeat?.seatId);
+    });
+  });
+
+  describe("scanAndBoard()", () => {
+    it("boards successfully within the boarding window", async () => {
+      const { schedule, seats } = await createTestSchedule({ trainNumber: `TIX-BOARD-OK-${Date.now()}`, departureAt: future(60), arrivalAt: future(120) });
+      const booking = await createOneWayBooking(schedule.id, seats[0].id);
+      await markSucceeded(booking.id);
+      await ticketsService.generate(booking.id);
+
+      const result = await ticketsService.scanAndBoard(booking.bookingRef, "gate-validator-1");
+      expect(result.success).toBe(true);
+      expect(result.boarding?.seat).toBe(seats[0].seatNumber);
+
+      const ticket = await harness.prisma.ticket.findFirst({ where: { bookingId: booking.id } });
+      expect(ticket?.validatedAt).toBeTruthy();
+    });
+
+    it("refuses boarding before the boarding window opens", async () => {
+      // Default boarding window is 4h (SystemConfigService DEFAULTS) — 6h out is still closed.
+      const { schedule, seats } = await createTestSchedule({ trainNumber: `TIX-BOARD-EARLY-${Date.now()}`, departureAt: future(360), arrivalAt: future(420) });
+      const booking = await createOneWayBooking(schedule.id, seats[0].id);
+      await markSucceeded(booking.id);
+      await ticketsService.generate(booking.id);
+
+      const result = await ticketsService.scanAndBoard(booking.bookingRef, "gate-validator-1");
+      expect(result.success).toBe(false);
+      expect(result.error).toMatch(/Boarding opens \d+ hour\(s\) before departure/i);
+    });
+
+    it("refuses boarding once departure has passed", async () => {
+      // Book while departure is comfortably in the future (holdSeats itself refuses a hold
+      // within 30min of departure), THEN move departure into the past — both the schedule's
+      // own departureAt AND the origin stop's plannedDepartureAt, since scanAndBoard resolves
+      // the boarding time via resolveBookingSegment(), which prefers the TripStopTime over
+      // the raw schedule field.
+      const { schedule, seats } = await createTestSchedule({ trainNumber: `TIX-BOARD-LATE-${Date.now()}`, departureAt: future(180), arrivalAt: future(240) });
+      const booking = await createOneWayBooking(schedule.id, seats[0].id);
+      await markSucceeded(booking.id);
+      await ticketsService.generate(booking.id);
+
+      const past = new Date(Date.now() - 60_000);
+      await harness.prisma.trainSchedule.update({ where: { id: schedule.id }, data: { departureAt: past } });
+      await harness.prisma.tripStopTime.updateMany({ where: { scheduleId: schedule.id, stationId: IDS.stationA }, data: { plannedDepartureAt: past } });
+
+      const result = await ticketsService.scanAndBoard(booking.bookingRef, "gate-validator-1");
+      expect(result.success).toBe(false);
+      expect(result.error).toMatch(/Boarding is closed/i);
+    });
+  });
+
+  describe("validate()", () => {
+    it("ONE_WAY: a second validate() call on the same ticket is idempotent, not an error", async () => {
+      const { schedule, seats } = await createTestSchedule({ trainNumber: `TIX-VAL-ONEWAY-${Date.now()}`, departureAt: future(60), arrivalAt: future(120) });
+      const booking = await createOneWayBooking(schedule.id, seats[0].id);
+      await markSucceeded(booking.id);
+      await ticketsService.generate(booking.id);
+
+      const first = await ticketsService.validate(booking.bookingRef, "gate-validator-1");
+      expect(first.validated).toBe(true);
+      expect((first as any).alreadyValidated).toBeUndefined();
+
+      const second = await ticketsService.validate(booking.bookingRef, "gate-validator-1");
+      expect(second.validated).toBe(true);
+      expect((second as any).alreadyValidated).toBe(true);
+    });
+  });
+});
diff --git a/apps/edr-passenger-web/backoffice/src/app/seats/page.tsx b/apps/edr-passenger-web/backoffice/src/app/seats/page.tsx
index be5449e97..3ce651ac8 100644
--- a/apps/edr-passenger-web/backoffice/src/app/seats/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/seats/page.tsx
@@ -2,11 +2,11 @@
 
 import { useState } from 'react';
 import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
-import { seatsApi, schedulesApi, fleetApi, routeCoachTemplatesApi } from '@/lib/api';
+import { seatsApi, schedulesApi, fleetApi, routeCoachTemplatesApi, bookingsApi } from '@/lib/api';
 import { routesApi } from '@/lib/api/routes';
 import Modal from '@/components/ui/Modal';
 import ActionButton from '@/components/ui/ActionButton'
-import { Armchair, Lock, Unlock, Bed, X, RotateCcw, ChevronDown, Train, Wrench } from 'lucide-react';
+import { Armchair, Lock, Unlock, Bed, X, RotateCcw, ChevronDown, Train, Wrench, Ticket as TicketIcon } from 'lucide-react';
 
 export default function SeatsPage() {
   const [activeTab, setActiveTab] = useState<'route' | 'schedule'>('route');
@@ -24,6 +24,22 @@ export default function SeatsPage() {
   const [coachToUnblock, setCoachToUnblock] = useState<any>(null);
   const [showMaintenanceModal, setShowMaintenanceModal] = useState(false);
   const [maintenanceReason, setMaintenanceReason] = useState('');
+  const [showIssueBookingModal, setShowIssueBookingModal] = useState(false);
+  const [issueBookingCoach, setIssueBookingCoach] = useState<any>(null);
+  const [issueBookingForm, setIssueBookingForm] = useState({
+    bookingKind: 'STAFF' as 'STAFF' | 'PASSENGER',
+    // No seatClassId — the seat's class is already fixed by the reservation; the backend
+    // resolves it from the seat's own coach type + nationality tier.
+    passengerName: '',
+    dateOfBirth: '',
+    idDocumentType: 'PASSPORT' as 'NATIONAL_ID' | 'PASSPORT',
+    idDocumentNumber: '',
+    passportNumber: '',
+    nationality: '' as '' | 'Ethiopian' | 'Djiboutian' | 'Other',
+    phone: '',
+    email: '',
+  });
+  const [issueBookingResult, setIssueBookingResult] = useState<{ payUrl?: string } | null>(null);
   const queryClient = useQueryClient();
 
   const { data: schedulesData } = useQuery({
@@ -105,6 +121,21 @@ export default function SeatsPage() {
     },
   });
 
+  const issueBookingMutation = useMutation({
+    mutationFn: ({ seatId, data }: { seatId: string; data: any }) =>
+      bookingsApi.issueFromReservation(seatId, data),
+    onSuccess: (result: any) => {
+      invalidateSeatData();
+      setIssueBookingResult({ payUrl: result?.payUrl });
+      if (!result?.payUrl) {
+        // STAFF booking — nothing further to show the admin, close immediately.
+        setShowIssueBookingModal(false);
+        setSelectedSeat(null);
+        setIssueBookingCoach(null);
+      }
+    },
+  });
+
   const removeSeatMutation = useMutation({
     mutationFn: (seatId: string) => seatsApi.removeSeat(seatId),
     onSuccess: () => {
@@ -186,11 +217,66 @@ export default function SeatsPage() {
   };
 
   const handleUnblock = async (seat: any) => {
-    if (confirm('Are you sure you want to unblock this seat?')) {
+    if (confirm('Release this reservation and make the seat available to the public?')) {
       await unblockMutation.mutateAsync(seat.id);
     }
   };
 
+  const handleIssueBooking = (seat: any, coach: any) => {
+    if (activeTab !== 'schedule' || !selectedSchedule) {
+      alert('Select a specific schedule (Schedule tab) to issue a booking for a reserved seat.');
+      return;
+    }
+    setSelectedSeat(seat);
+    setIssueBookingCoach(coach);
+    setIssueBookingResult(null);
+    setIssueBookingForm({
+      bookingKind: 'STAFF',
+      passengerName: '',
+      dateOfBirth: '',
+      idDocumentType: 'PASSPORT',
+      idDocumentNumber: '',
+      passportNumber: '',
+      nationality: '',
+      phone: '',
+      email: '',
+    });
+    setShowIssueBookingModal(true);
+  };
+
+  const submitIssueBooking = async () => {
+    const schedule = schedules.find((s: any) => s.id === selectedSchedule);
+    if (!schedule?.originStation?.id || !schedule?.destinationStation?.id) {
+      alert('Could not resolve this schedule\'s origin/destination stations.');
+      return;
+    }
+    if (!issueBookingForm.passengerName.trim() || !issueBookingForm.dateOfBirth) {
+      alert('Traveler name and date of birth are required.');
+      return;
+    }
+    if (!issueBookingForm.nationality) {
+      alert('Select a nationality.');
+      return;
+    }
+    if (issueBookingForm.idDocumentType === 'PASSPORT' && !issueBookingForm.passportNumber.trim()) {
+      alert('Passport number is required.');
+      return;
+    }
+    if (issueBookingForm.bookingKind === 'PASSENGER' && !issueBookingForm.phone.trim()) {
+      alert('Phone number is required for a passenger booking (used to send the payment link).');
+      return;
+    }
+    await issueBookingMutation.mutateAsync({
+      seatId: selectedSeat.id,
+      data: {
+        scheduleId: selectedSchedule,
+        originStationId: schedule.originStation.id,
+        destinationStationId: schedule.destinationStation.id,
+        ...issueBookingForm,
+      },
+    });
+  };
+
   const handleRemoveSeat = (seat: any) => {
     setSelectedSeat(seat);
     setShowRemoveModal(true);
@@ -252,7 +338,7 @@ export default function SeatsPage() {
 
   const submitBlock = async () => {
     if (!blockReason.trim()) {
-      alert('Please provide a reason for blocking');
+      alert('Please provide a reason for the reservation');
       return;
     }
     await blockMutation.mutateAsync({ seatId: selectedSeat.id, reason: blockReason });
@@ -350,6 +436,7 @@ export default function SeatsPage() {
                       handleUndoRemove={handleUndoRemove}
                       handleSetMaintenance={handleSetMaintenance}
                       handleClearMaintenance={handleClearMaintenance}
+                      handleIssueBooking={handleIssueBooking}
                       hideNumber={true}
                     />
                   ))}
@@ -445,6 +532,7 @@ export default function SeatsPage() {
                       handleUndoRemove={handleUndoRemove}
                       handleSetMaintenance={handleSetMaintenance}
                       handleClearMaintenance={handleClearMaintenance}
+                      handleIssueBooking={handleIssueBooking}
                       hideNumber={true}
                     />
                   ))}
@@ -467,6 +555,7 @@ export default function SeatsPage() {
                         handleUndoRemove={handleUndoRemove}
                         handleSetMaintenance={handleSetMaintenance}
                         handleClearMaintenance={handleClearMaintenance}
+                      handleIssueBooking={handleIssueBooking}
                         hideNumber={true}
                       />
                     ))}
@@ -749,15 +838,15 @@ export default function SeatsPage() {
           setSelectedSeat(null);
           setBlockReason('');
         }}
-        title="Block Seat"
+        title="Reserve Seat"
         size="md"
       >
         <div className="space-y-4">
           <p className="text-sm text-muted-foreground">
-            Block seat <strong>{selectedSeat?.seatNumber}</strong> in Coach <strong>{selectedSeat?.coach?.coachNumber}</strong>
+            Reserve seat <strong>{selectedSeat?.seatNumber}</strong> in Coach <strong>{selectedSeat?.coach?.coachNumber}</strong>
           </p>
           <div>
-            <label className="label">Reason for Blocking *</label>
+            <label className="label">Reason for Reservation *</label>
             <textarea
               className="input"
               rows={3}
@@ -782,12 +871,184 @@ export default function SeatsPage() {
               loading={blockMutation.isPending}
               disabled={!blockReason.trim()}
             >
-              Block Seat
+              Reserve Seat
             </ActionButton>
           </div>
         </div>
       </Modal>
 
+      <Modal
+        isOpen={showIssueBookingModal}
+        onClose={() => {
+          setShowIssueBookingModal(false);
+          setSelectedSeat(null);
+          setIssueBookingCoach(null);
+          setIssueBookingResult(null);
+        }}
+        title="Issue Booking"
+        size="md"
+      >
+        {issueBookingResult?.payUrl ? (
+          <div className="space-y-4">
+            <p className="text-sm text-muted-foreground">
+              Booking created. A payment link has been sent via SMS to the traveler.
+            </p>
+            <div className="input break-all text-xs">{issueBookingResult.payUrl}</div>
+            <div className="flex justify-end">
+              <ActionButton
+                onClick={() => {
+                  setShowIssueBookingModal(false);
+                  setSelectedSeat(null);
+                  setIssueBookingCoach(null);
+                  setIssueBookingResult(null);
+                }}
+              >
+                Done
+              </ActionButton>
+            </div>
+          </div>
+        ) : (
+          <div className="space-y-4">
+            <p className="text-sm text-muted-foreground">
+              Issue a booking for seat <strong>{selectedSeat?.seatNumber}</strong> in Coach{' '}
+              <strong>{issueBookingCoach?.coachNumber}</strong>
+            </p>
+
+            <div>
+              <label className="label">Booking Type *</label>
+              <div className="flex gap-2">
+                <button
+                  type="button"
+                  className={`flex-1 px-3 py-2 rounded border ${issueBookingForm.bookingKind === 'STAFF' ? 'bg-blue-600 text-white border-blue-600' : 'border-gray-300 dark:border-gray-600'}`}
+                  onClick={() => setIssueBookingForm((f) => ({ ...f, bookingKind: 'STAFF' }))}
+                >
+                  Staff (no fee)
+                </button>
+                <button
+                  type="button"
+                  className={`flex-1 px-3 py-2 rounded border ${issueBookingForm.bookingKind === 'PASSENGER' ? 'bg-blue-600 text-white border-blue-600' : 'border-gray-300 dark:border-gray-600'}`}
+                  onClick={() => setIssueBookingForm((f) => ({ ...f, bookingKind: 'PASSENGER' }))}
+                >
+                  Passenger (pay via link)
+                </button>
+              </div>
+            </div>
+
+            <div>
+              <label className="label">Traveler Name *</label>
+              <input
+                className="input"
+                value={issueBookingForm.passengerName}
+                onChange={(e) => setIssueBookingForm((f) => ({ ...f, passengerName: e.target.value }))}
+              />
+            </div>
+
+            <div className="grid grid-cols-2 gap-3">
+              <div>
+                <label className="label">Date of Birth *</label>
+                <input
+                  type="date"
+                  className="input"
+                  value={issueBookingForm.dateOfBirth}
+                  onChange={(e) => setIssueBookingForm((f) => ({ ...f, dateOfBirth: e.target.value }))}
+                />
+              </div>
+              <div>
+                <label className="label">Nationality *</label>
+                <select
+                  className="input"
+                  value={issueBookingForm.nationality}
+                  onChange={(e) => {
+                    const nationality = e.target.value as 'Ethiopian' | 'Djiboutian' | 'Other';
+                    setIssueBookingForm((f) => ({
+                      ...f,
+                      nationality,
+                      // National ID is Ethiopian-only — switch back to Passport for anyone else.
+                      idDocumentType: nationality === 'Ethiopian' ? f.idDocumentType : 'PASSPORT',
+                    }));
+                  }}
+                >
+                  <option value="">Select nationality...</option>
+                  <option value="Ethiopian">Ethiopian</option>
+                  <option value="Djiboutian">Djiboutian</option>
+                  <option value="Other">Other</option>
+                </select>
+              </div>
+            </div>
+
+            <div>
+              <label className="label">ID Document Type *</label>
+              <select
+                className="input"
+                value={issueBookingForm.idDocumentType}
+                onChange={(e) => setIssueBookingForm((f) => ({ ...f, idDocumentType: e.target.value as 'NATIONAL_ID' | 'PASSPORT' }))}
+              >
+                <option value="PASSPORT">Passport</option>
+                {issueBookingForm.nationality === 'Ethiopian' && (
+                  <option value="NATIONAL_ID">National ID</option>
+                )}
+              </select>
+            </div>
+
+            {issueBookingForm.idDocumentType === 'NATIONAL_ID' ? (
+              <div>
+                <label className="label">National ID Number</label>
+                <input
+                  className="input"
+                  value={issueBookingForm.idDocumentNumber}
+                  onChange={(e) => setIssueBookingForm((f) => ({ ...f, idDocumentNumber: e.target.value }))}
+                />
+              </div>
+            ) : (
+              <div>
+                <label className="label">Passport Number *</label>
+                <input
+                  className="input"
+                  value={issueBookingForm.passportNumber}
+                  onChange={(e) => setIssueBookingForm((f) => ({ ...f, passportNumber: e.target.value }))}
+                />
+              </div>
+            )}
+
+            <div className="grid grid-cols-2 gap-3">
+              <div>
+                <label className="label">Phone{issueBookingForm.bookingKind === 'PASSENGER' ? ' * (payment link sent here)' : ''}</label>
+                <input
+                  className="input"
+                  value={issueBookingForm.phone}
+                  onChange={(e) => setIssueBookingForm((f) => ({ ...f, phone: e.target.value }))}
+                  placeholder="+251911234567"
+                />
+              </div>
+              <div>
+                <label className="label">Email</label>
+                <input
+                  className="input"
+                  value={issueBookingForm.email}
+                  onChange={(e) => setIssueBookingForm((f) => ({ ...f, email: e.target.value }))}
+                />
+              </div>
+            </div>
+
+            <div className="flex justify-end gap-2">
+              <ActionButton
+                variant="secondary"
+                onClick={() => {
+                  setShowIssueBookingModal(false);
+                  setSelectedSeat(null);
+                  setIssueBookingCoach(null);
+                }}
+              >
+                Cancel
+              </ActionButton>
+              <ActionButton onClick={submitIssueBooking} loading={issueBookingMutation.isPending}>
+                {issueBookingForm.bookingKind === 'STAFF' ? 'Issue Ticket' : 'Send Payment Link'}
+              </ActionButton>
+            </div>
+          </div>
+        )}
+      </Modal>
+
       <Modal
         isOpen={showRemoveModal}
         onClose={() => {
@@ -973,6 +1234,7 @@ interface SeatIconProps {
   handleUndoRemove: (seat: any) => void;
   handleSetMaintenance: (seat: any) => void;
   handleClearMaintenance: (seat: any) => void;
+  handleIssueBooking: (seat: any, coach: any) => void;
 }
 
 function SeatIcon({
@@ -989,6 +1251,7 @@ function SeatIcon({
   handleUndoRemove,
   handleSetMaintenance,
   handleClearMaintenance,
+  handleIssueBooking,
 }: SeatIconProps) {
   const isRemoved = seat.seatNumber && seat.seatNumber.startsWith('-');
   const seatClassStr = typeof coach?.seatClass === 'string' ? coach.seatClass : (coach?.seatClass?.name || coach?.coachClass || '');
@@ -1058,7 +1321,7 @@ function SeatIcon({
               <button
                 onClick={() => handleBlock(seat)}
                 className="p-1 bg-white rounded hover:bg-gray-100 pointer-events-auto"
-                title="Block seat"
+                title="Reserve seat"
               >
                 <Lock className="h-3 w-3 text-gray-700" />
               </button>
@@ -1072,13 +1335,22 @@ function SeatIcon({
             </>
           )}
           {canUnblock && (
-            <button
-              onClick={() => handleUnblock(seat)}
-              className="p-1 bg-white rounded hover:bg-gray-100 pointer-events-auto"
-              title="Unblock seat"
-            >
-              <Unlock className="h-3 w-3 text-gray-700" />
-            </button>
+            <>
+              <button
+                onClick={() => handleUnblock(seat)}
+                className="p-1 bg-white rounded hover:bg-gray-100 pointer-events-auto"
+                title="Release reservation"
+              >
+                <Unlock className="h-3 w-3 text-gray-700" />
+              </button>
+              <button
+                onClick={() => handleIssueBooking(seat, coach)}
+                className="p-1 bg-white rounded hover:bg-gray-100 pointer-events-auto"
+                title="Issue booking"
+              >
+                <TicketIcon className="h-3 w-3 text-gray-700" />
+              </button>
+            </>
           )}
           {canMaintenance && (
             <button
diff --git a/apps/edr-passenger-web/backoffice/src/lib/api/index.ts b/apps/edr-passenger-web/backoffice/src/lib/api/index.ts
index 0d35ed2d3..febb94931 100644
--- a/apps/edr-passenger-web/backoffice/src/lib/api/index.ts
+++ b/apps/edr-passenger-web/backoffice/src/lib/api/index.ts
@@ -48,6 +48,10 @@ export const bookingsApi = {
     apiClient.post<any>(`/payments/${bookingId}/force-confirm`, data),
   smartAssign: (bookingId: string) =>
     apiClient.post<any>(`/tickets/smart-assign/${bookingId}`, {}),
+  // Converts a reserved (blocked) seat into a real booking — STAFF (fee-waived, ticket
+  // issued immediately) or PASSENGER (payment link texted to the traveler's phone).
+  issueFromReservation: (seatId: string, data: any) =>
+    apiClient.post<any>(`/bookings/reservations/${seatId}/issue`, data),
 };
 
 // Passengers API
diff --git a/apps/edr-passenger-web/portal/src/app/reserve/pay/[token]/failed/page.tsx b/apps/edr-passenger-web/portal/src/app/reserve/pay/[token]/failed/page.tsx
new file mode 100644
index 000000000..4297a3806
--- /dev/null
+++ b/apps/edr-passenger-web/portal/src/app/reserve/pay/[token]/failed/page.tsx
@@ -0,0 +1,24 @@
+"use client";
+
+import { useParams } from "next/navigation";
+import { XCircle } from "lucide-react";
+import Link from "next/link";
+
+export default function ReservationPayFailedPage() {
+  const { token } = useParams<{ token: string }>();
+
+  return (
+    <div className="min-h-screen bg-gray-50 dark:bg-gray-950 flex items-center justify-center px-4">
+      <div className="max-w-sm w-full text-center space-y-4">
+        <XCircle className="w-16 h-16 text-red-500 mx-auto" />
+        <h1 className="text-2xl font-bold text-gray-900 dark:text-gray-100">Payment failed</h1>
+        <p className="text-sm text-gray-500 dark:text-gray-400">
+          Your payment could not be completed. Please try again.
+        </p>
+        <Link href={`/reserve/pay/${token}`} className="btn-primary inline-block px-6 py-2.5 font-semibold">
+          Try again
+        </Link>
+      </div>
+    </div>
+  );
+}
diff --git a/apps/edr-passenger-web/portal/src/app/reserve/pay/[token]/page.tsx b/apps/edr-passenger-web/portal/src/app/reserve/pay/[token]/page.tsx
new file mode 100644
index 000000000..8999ad939
--- /dev/null
+++ b/apps/edr-passenger-web/portal/src/app/reserve/pay/[token]/page.tsx
@@ -0,0 +1,211 @@
+"use client";
+
+import { useState } from "react";
+import { useParams, useRouter } from "next/navigation";
+import { useQuery, useMutation } from "@tanstack/react-query";
+import { apiClient } from "@/lib/api-client";
+import { PaymentMethod } from "@/types";
+import {
+  Loader2,
+  CreditCard,
+  Smartphone,
+  Wallet,
+  Landmark,
+  CheckCircle,
+  AlertCircle,
+} from "lucide-react";
+
+const getIconForMethod = (methodId: string) => {
+  if (methodId.includes("CARD")) return CreditCard;
+  if (methodId.includes("WALLET")) return Wallet;
+  if (methodId.includes("CAC")) return Landmark;
+  return Smartphone;
+};
+
+/**
+ * Standalone pay-by-link page for a booking issued via the backoffice's "reserve seat →
+ * issue booking (passenger)" flow — no portal login/session required, unlike the normal
+ * /booking/payment page which depends on client-side booking-store state populated during
+ * a live search→seats→review session. Cloned from /pay-balance/[token] (same pattern:
+ * resolve-by-token, method picker, single pay button) but pointed at a booking instead of a
+ * supplementary charge, and reusing the SAME already-public booking-payment endpoints
+ * (/payments/initiate, /payments/methods) the normal payment page calls — no new payment
+ * mechanics, just a session-free entry point.
+ */
+export default function ReservationPayPage() {
+  const { token } = useParams<{ token: string }>();
+  const router = useRouter();
+  const [selectedMethod, setSelectedMethod] = useState<string | null>(null);
+  const [isProcessing, setIsProcessing] = useState(false);
+  const [paymentError, setPaymentError] = useState<string | null>(null);
+
+  const { data: booking, isLoading: loadingBooking, error: bookingError } = useQuery({
+    queryKey: ["reservation-booking", token],
+    queryFn: () => apiClient.get<any>(`/bookings/pay/${token}`),
+    retry: false,
+  });
+
+  const { data: paymentMethods = [], isLoading: loadingMethods } = useQuery<PaymentMethod[]>({
+    queryKey: ["paymentMethods"],
+    queryFn: async () => {
+      const res = await apiClient.get<PaymentMethod[]>("/payments/methods");
+      return Array.isArray(res) ? res : [];
+    },
+    enabled: !!booking,
+  });
+
+  const payMutation = useMutation({
+    mutationFn: (method: string) =>
+      apiClient.post<any>("/payments/initiate", {
+        bookingId: booking.id,
+        method,
+        platform: "web",
+      }),
+    onSuccess: (data: any) => {
+      if (data?.clientAction?.type === "REDIRECT") {
+        window.location.href = data.clientAction.url;
+        return;
+      }
+      router.push(`/reserve/pay/${token}/success`);
+    },
+    onError: (err: any) => {
+      setPaymentError(
+        err?.response?.data?.message ?? err?.message ?? "Payment failed. Please try again."
+      );
+      setIsProcessing(false);
+    },
+  });
+
+  const handlePay = () => {
+    if (!selectedMethod) return;
+    setIsProcessing(true);
+    setPaymentError(null);
+    payMutation.mutate(selectedMethod);
+  };
+
+  if (loadingBooking) {
+    return (
+      <div className="min-h-screen flex items-center justify-center">
+        <Loader2 className="w-10 h-10 text-primary animate-spin" />
+      </div>
+    );
+  }
+
+  if (bookingError || !booking) {
+    const msg = (bookingError as any)?.response?.data?.message ?? "This payment link is invalid or has expired.";
+    return (
+      <div className="min-h-screen flex items-center justify-center px-4">
+        <div className="max-w-sm w-full text-center space-y-4">
+          <AlertCircle className="w-14 h-14 text-red-500 mx-auto" />
+          <h1 className="text-xl font-bold text-gray-900 dark:text-gray-100">Link unavailable</h1>
+          <p className="text-sm text-gray-500 dark:text-gray-400">{msg}</p>
+        </div>
+      </div>
+    );
+  }
+
+  const currency = booking.displayCurrency ?? booking.currency ?? "ETB";
+  const amountMinor = booking.displayTotalMinor ?? booking.totalMinor;
+  const amountDisplay = (amountMinor / 100).toFixed(2);
+  const seat = booking.seats?.[0];
+
+  return (
+    <div className="min-h-screen bg-gray-50 dark:bg-gray-950 flex items-start justify-center px-4 py-10">
+      <div className="w-full max-w-md space-y-4">
+        <div className="text-center space-y-1">
+          <h1 className="text-2xl font-bold text-gray-900 dark:text-gray-100">Complete your booking</h1>
+          <p className="text-sm text-gray-500 dark:text-gray-400">
+            Booking <span className="font-semibold text-gray-700 dark:text-gray-300">{booking.bookingRef}</span>
+          </p>
+        </div>
+
+        <div className="card space-y-3">
+          <div className="flex justify-between items-center">
+            <span className="text-sm text-gray-500 dark:text-gray-400">Route</span>
+            <span className="text-sm font-medium text-gray-900 dark:text-gray-100">
+              {booking.schedule?.origin?.name} → {booking.schedule?.destination?.name}
+            </span>
+          </div>
+          <div className="flex justify-between items-center">
+            <span className="text-sm text-gray-500 dark:text-gray-400">Departure</span>
+            <span className="text-sm font-medium text-gray-900 dark:text-gray-100">
+              {booking.schedule?.departureAt ? new Date(booking.schedule.departureAt).toLocaleString() : "N/A"}
+            </span>
+          </div>
+          {seat && (
+            <div className="flex justify-between items-center">
+              <span className="text-sm text-gray-500 dark:text-gray-400">Seat</span>
+              <span className="text-sm font-medium text-gray-900 dark:text-gray-100">
+                {seat.seatNumber} {seat.coach ? `(Coach ${seat.coach})` : ""}
+              </span>
+            </div>
+          )}
+          <div className="border-t border-gray-100 dark:border-gray-800 pt-3 flex justify-between items-center">
+            <span className="font-bold text-gray-900 dark:text-gray-100">Amount due</span>
+            <span className="text-2xl font-bold text-primary">{currency} {amountDisplay}</span>
+          </div>
+        </div>
+
+        <div className="card space-y-3">
+          <h2 className="text-base font-bold text-gray-900 dark:text-gray-100">Select payment method</h2>
+          {loadingMethods ? (
+            <div className="flex items-center justify-center py-6 gap-2">
+              <Loader2 className="w-5 h-5 text-primary animate-spin" />
+              <span className="text-sm text-gray-500 dark:text-gray-400">Loading...</span>
+            </div>
+          ) : (
+            <div className="space-y-2">
+              {paymentMethods.filter((m) => m.enabled).map((method) => {
+                const Icon = getIconForMethod(method.type);
+                const isSelected = selectedMethod === method.type;
+                return (
+                  <button
+                    key={method.id}
+                    onClick={() => setSelectedMethod(method.type)}
+                    disabled={isProcessing}
+                    className={`w-full p-4 rounded-xl border-2 transition-all text-left ${
+                      isSelected
+                        ? "border-primary bg-primary/8 dark:bg-primary/15 shadow-md"
+                        : "border-gray-200 dark:border-gray-700 bg-white dark:bg-gray-800 hover:border-primary/50"
+                    } ${isProcessing ? "opacity-50 cursor-not-allowed" : ""}`}
+                  >
+                    <div className="flex items-center gap-3">
+                      <div className={`w-10 h-10 rounded-lg flex items-center justify-center flex-shrink-0 ${isSelected ? "bg-primary" : "bg-gray-100 dark:bg-gray-700"}`}>
+                        <Icon className={`w-5 h-5 ${isSelected ? "text-white" : "text-primary"}`} />
+                      </div>
+                      <div className="flex-1 min-w-0">
+                        <p className="font-semibold text-gray-900 dark:text-gray-100">{method.displayName}</p>
+                        <p className="text-xs text-gray-500 dark:text-gray-400">{method.region} · {method.currency}</p>
+                      </div>
+                      {isSelected && <CheckCircle className="w-5 h-5 text-primary flex-shrink-0" />}
+                    </div>
+                  </button>
+                );
+              })}
+            </div>
+          )}
+        </div>
+
+        {paymentError && (
+          <p className="text-red-600 dark:text-red-400 text-sm text-center">⚠️ {paymentError}</p>
+        )}
+
+        <button
+          onClick={handlePay}
+          disabled={!selectedMethod || isProcessing}
+          className="btn-primary w-full py-3 font-semibold disabled:opacity-50 disabled:cursor-not-allowed"
+        >
+          {isProcessing ? (
+            <span className="flex items-center justify-center gap-2">
+              <Loader2 className="w-4 h-4 animate-spin" /> Processing...
+            </span>
+          ) : (
+            `Pay ${currency} ${amountDisplay}`
+          )}
+        </button>
+
+        <p className="text-xs text-gray-400 dark:text-gray-500 text-center">🔒 Secure & encrypted payment</p>
+      </div>
+    </div>
+  );
+}
diff --git a/apps/edr-passenger-web/portal/src/app/reserve/pay/[token]/success/page.tsx b/apps/edr-passenger-web/portal/src/app/reserve/pay/[token]/success/page.tsx
new file mode 100644
index 000000000..9ae6f7a17
--- /dev/null
+++ b/apps/edr-passenger-web/portal/src/app/reserve/pay/[token]/success/page.tsx
@@ -0,0 +1,21 @@
+"use client";
+
+import { CheckCircle } from "lucide-react";
+import Link from "next/link";
+
+export default function ReservationPaySuccessPage() {
+  return (
+    <div className="min-h-screen bg-gray-50 dark:bg-gray-950 flex items-center justify-center px-4">
+      <div className="max-w-sm w-full text-center space-y-4">
+        <CheckCircle className="w-16 h-16 text-green-500 mx-auto" />
+        <h1 className="text-2xl font-bold text-gray-900 dark:text-gray-100">Payment successful</h1>
+        <p className="text-sm text-gray-500 dark:text-gray-400">
+          Your booking is confirmed. Your ticket has been sent to you.
+        </p>
+        <Link href="/" className="btn-primary inline-block px-6 py-2.5 font-semibold">
+          Back to home
+        </Link>
+      </div>
+    </div>
+  );
+}
diff --git a/e2e-ui-report/index.html b/e2e-ui-report/index.html
index ba053244d..8428f4890 100644
--- a/e2e-ui-report/index.html
+++ b/e2e-ui-report/index.html
@@ -87,4 +87,4 @@ Error generating stack: `+l.message+`
     <div id='root'></div>
   </body>
 </html>
-<template id="playwrightReportBase64">data:application/zip;base64,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</template>
\ No newline at end of file
+<template id="playwrightReportBase64">data:application/zip;base64,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</template>
\ No newline at end of file
diff --git a/e2e-ui/specs/backoffice/checkin-cutoff.spec.ts b/e2e-ui/specs/backoffice/checkin-cutoff.spec.ts
index b123f24bc..1ddc95d12 100644
--- a/e2e-ui/specs/backoffice/checkin-cutoff.spec.ts
+++ b/e2e-ui/specs/backoffice/checkin-cutoff.spec.ts
@@ -24,9 +24,9 @@ test("BC-11 ✅ travelMinutesToStop drives each stop's estimated arrival indepen
       name: "E2E Check-in Cutoff Route",
       effectiveFrom: "2020-01-01T00:00:00Z",
       stops: [
-        { stationId: STATIONS.A, sequence: 1 },
-        { stationId: STATIONS.B, sequence: 2, travelMinutesToStop: 60 },
-        { stationId: STATIONS.C, sequence: 3, travelMinutesToStop: 40 },
+        { stationId: STATIONS.A, sequence: 1, distanceKm: 0 },
+        { stationId: STATIONS.B, sequence: 2, travelMinutesToStop: 60, distanceKm: 60 },
+        { stationId: STATIONS.C, sequence: 3, travelMinutesToStop: 40, distanceKm: 100 },
       ],
     },
   });
diff --git a/e2e-ui/specs/backoffice/config-validation.spec.ts b/e2e-ui/specs/backoffice/config-validation.spec.ts
index 6749a1b8a..e8bb3ecde 100644
--- a/e2e-ui/specs/backoffice/config-validation.spec.ts
+++ b/e2e-ui/specs/backoffice/config-validation.spec.ts
@@ -71,7 +71,15 @@ test("BC-10 ✅ a schedule with a past departure is rejected by the API (past-da
   const arr = new Date(dep.getTime() + 4 * 3600e3);
   const okRes = await request.post(`${API_URL}/schedules`, {
     headers: auth(),
-    data: { trainId: UI_IDS.train, routeId: ROUTE_ID, departureAt: dep.toISOString(), arrivalAt: arr.toISOString() },
+    // ROUTE_ID has no route coach template, so createSchedule needs an explicit coach or it 400s
+    // on the "zero coaches assigned" guard (see schedules.service.ts).
+    data: {
+      trainId: UI_IDS.train,
+      routeId: ROUTE_ID,
+      departureAt: dep.toISOString(),
+      arrivalAt: arr.toISOString(),
+      coachIds: [UI_IDS.coach],
+    },
   });
   expect(okRes.ok()).toBeTruthy();
   const sched = (await okRes.json())?.data ?? {};