diff --git a/resources/js/pages/Stages/Edit.vue b/resources/js/pages/Stages/Edit.vue
index 01f101e..e7c7bdc 100644
--- a/resources/js/pages/Stages/Edit.vue
+++ b/resources/js/pages/Stages/Edit.vue
@@ -128,16 +128,45 @@ const qualifierTotal = computed(() => {
 
 const qualifierTotalIsPowerOfTwo = computed(() => qualifierTotal.value >= 2 && (qualifierTotal.value & (qualifierTotal.value - 1)) === 0);
 
-const entrantTokens = ref<string[]>(((props.stage.config?.entrants as Entrant[] | undefined) ?? []).map(tokenOf));
+/**
+ * The bracket is a fixed set of slots (one per qualifier) that start empty
+ * and get a qualifier dropped into each. slots[2i] / slots[2i+1] are the two
+ * sides of round-1 match i, and the order of the matches is the bracket tree.
+ * We only mirror them into the saved entrants once every slot is filled — a
+ * half-built bracket isn't a valid one.
+ */
+const bracketSize = computed(() => (qualifierTotalIsPowerOfTwo.value ? qualifierTotal.value : 0));
+
+function initialSlots(): (string | null)[] {
+    const saved = ((props.stage.config?.entrants as Entrant[] | undefined) ?? []).map(tokenOf);
+
+    if (bracketSize.value === 0) {
+        return saved;
+    }
+
+    return Array.from({ length: bracketSize.value }, (_, index) => saved[index] ?? null);
+}
+
+const slots = ref<(string | null)[]>(initialSlots());
 
 watch(
-    entrantTokens,
-    (tokens) => {
-        form.config.entrants = tokens.length > 0 ? tokens.map(entrantOf) : null;
+    slots,
+    (value) => {
+        const filled = value.length > 0 && value.every((token): token is string => token !== null);
+        form.config.entrants = filled ? (value as string[]).map(entrantOf) : null;
     },
     { deep: true },
 );
 
+const matchCount = computed(() => slots.value.length / 2);
+const placedCount = computed(() => slots.value.filter((token) => token !== null).length);
+const firstRoundLabel = computed(() => roundLabelFor(matchCount.value));
+
+/** The two slot indices of a 1-based match number. */
+function matchSlots(match: number): [number, number] {
+    return [2 * (match - 1), 2 * (match - 1) + 1];
+}
+
 /**
  * Classic template for even group counts with exactly 2 qualifiers and no
  * best-placed spots: 1A v 2B, 1C v 2D, …, then 1B v 2A, 1D v 2C, … so
@@ -159,7 +188,9 @@ function applyClassicTemplate(): void {
         secondHalf.push(`group|${groups[i + 1]}|1`, `group|${groups[i]}|2`);
     }
 
-    entrantTokens.value = [...firstHalf, ...secondHalf];
+    slots.value = [...firstHalf, ...secondHalf];
+    selected.value = null;
+    selectedMatch.value = null;
 }
 
 /**
@@ -196,13 +227,290 @@ function applySeededTemplate(): void {
         seeds = next;
     }
 
-    entrantTokens.value = seeds.map((seed) => seedList[seed - 1]);
+    slots.value = seeds.map((seed) => seedList[seed - 1]);
+    selected.value = null;
+    selectedMatch.value = null;
 }
 
 function clearEntrants(): void {
-    entrantTokens.value = [];
+    slots.value = Array.from({ length: bracketSize.value }, () => null);
+    selected.value = null;
+    selectedMatch.value = null;
+}
+
+/**
+ * Full slot label, e.g. "Winner Group A" → "Winner A", "Best-placed #3" →
+ * "3rd #3". The group's "Group " prefix is dropped so chips stay compact.
+ */
+function slotLabel(token: string): string {
+    const parts = token.split('|');
+
+    if (parts[0] === 'best') {
+        return `3rd #${parts[1]}`;
+    }
+
+    const group = parts[1].replace(/^Group\s+/i, '');
+    const position = Number(parts[2]);
+
+    if (position === 1) {
+        return `Winner ${group}`;
+    }
+
+    if (position === 2) {
+        return `Runner-up ${group}`;
+    }
+
+    const suffix = position % 10 === 3 && position % 100 !== 13 ? 'rd' : 'th';
+
+    return `${position}${suffix} ${group}`;
+}
+
+type SlotKind = 'winner' | 'ru' | 'third' | 'other';
+
+function kindForToken(token: string): SlotKind {
+    const parts = token.split('|');
+
+    if (parts[0] === 'best') {
+        return 'third';
+    }
+
+    const position = Number(parts[2]);
+
+    return position === 1 ? 'winner' : position === 2 ? 'ru' : 'other';
+}
+
+function dotClass(kind: SlotKind): string {
+    return { winner: 'bg-primary', ru: 'bg-sky-500', third: 'bg-amber-500', other: 'bg-muted-foreground' }[kind];
+}
+
+/** Qualifier chips grouped by kind, marking the ones already on the bracket. */
+const paletteGroups = computed<{ label: string; chips: { token: string; label: string; kind: SlotKind; placed: boolean }[] }[]>(() => {
+    const placed = new Set(slots.value.filter((token): token is string => token !== null));
+    const labels: Record<SlotKind, string> = {
+        winner: 'Group winners',
+        ru: 'Runners-up',
+        third: 'Best-placed',
+        other: 'Other qualifiers',
+    };
+    const grouped: Record<SlotKind, { token: string; label: string; kind: SlotKind; placed: boolean }[]> = { winner: [], ru: [], third: [], other: [] };
+
+    for (const option of slotOptions.value) {
+        const kind = kindForToken(option.value);
+        grouped[kind].push({ token: option.value, label: slotLabel(option.value), kind, placed: placed.has(option.value) });
+    }
+
+    return (['winner', 'ru', 'third', 'other'] as SlotKind[])
+        .filter((kind) => grouped[kind].length > 0)
+        .map((kind) => ({ label: labels[kind], chips: grouped[kind] }));
+});
+
+// ----- drag and drop (native, no dependency) -----
+
+type DragState = { kind: 'chip'; token: string; from: number | null } | { kind: 'match'; index: number };
+
+const drag = ref<DragState | null>(null);
+const overSlot = ref<number | null>(null);
+const dropMatch = ref<{ index: number; after: boolean } | null>(null);
+
+function assignSlot(token: string, index: number, from: number | null): void {
+    const next = [...slots.value];
+    const occupant = next[index];
+    next[index] = token;
+
+    // Dragged out of another slot: leave the source empty, or swap when the
+    // target was occupied.
+    if (from !== null) {
+        next[from] = occupant && occupant !== token ? occupant : null;
+    }
+
+    slots.value = next;
+}
+
+function unassignSlot(index: number): void {
+    const next = [...slots.value];
+    next[index] = null;
+    slots.value = next;
+}
+
+/** Move round-1 match `from` to position `to`, sliding the rest along. */
+function moveMatch(from: number, to: number): void {
+    if (from === to) {
+        return;
+    }
+
+    const pairs: [string | null, string | null][] = [];
+    for (let i = 0; i < slots.value.length; i += 2) {
+        pairs.push([slots.value[i], slots.value[i + 1]]);
+    }
+
+    const [pair] = pairs.splice(from, 1);
+    pairs.splice(to, 0, pair);
+    slots.value = pairs.flat();
+}
+
+function onChipDragStart(event: DragEvent, token: string, from: number | null): void {
+    drag.value = { kind: 'chip', token, from };
+    // Firefox only starts a drag once data is set; the value itself is unused.
+    event.dataTransfer?.setData('text/plain', token);
+
+    if (event.dataTransfer) {
+        event.dataTransfer.effectAllowed = 'move';
+    }
+}
+
+function onMatchDragStart(event: DragEvent, index: number): void {
+    drag.value = { kind: 'match', index };
+    event.dataTransfer?.setData('text/plain', `match:${index}`);
+
+    if (event.dataTransfer) {
+        event.dataTransfer.effectAllowed = 'move';
+    }
+}
+
+function onDragEnd(): void {
+    drag.value = null;
+    overSlot.value = null;
+    dropMatch.value = null;
+}
+
+function onSlotDragOver(event: DragEvent, index: number): void {
+    if (drag.value?.kind !== 'chip') {
+        return;
+    }
+
+    event.preventDefault();
+    overSlot.value = index;
+}
+
+function onSlotDrop(index: number): void {
+    if (drag.value?.kind !== 'chip') {
+        return;
+    }
+
+    assignSlot(drag.value.token, index, drag.value.from);
+    onDragEnd();
+}
+
+function dropTargetAfter(event: DragEvent): boolean {
+    const rect = (event.currentTarget as HTMLElement).getBoundingClientRect();
+
+    return event.clientY > rect.top + rect.height / 2;
+}
+
+function onMatchDragOver(event: DragEvent, index: number): void {
+    if (drag.value?.kind !== 'match') {
+        return;
+    }
+
+    event.preventDefault();
+    dropMatch.value = { index, after: dropTargetAfter(event) };
+}
+
+function onMatchDrop(event: DragEvent, index: number): void {
+    if (drag.value?.kind !== 'match') {
+        return;
+    }
+
+    let to = index + (dropTargetAfter(event) ? 1 : 0);
+
+    if (drag.value.index < to) {
+        to -= 1;
+    }
+
+    moveMatch(drag.value.index, to);
+    onDragEnd();
+}
+
+// ----- tap to place (works on touch, where native drag never fires) -----
+
+const selected = ref<{ token: string; from: number | null } | null>(null);
+
+function isSelected(token: string, from: number | null): boolean {
+    return selected.value?.token === token && selected.value.from === from;
+}
+
+function onChipTap(token: string): void {
+    selected.value = isSelected(token, null) ? null : { token, from: null };
+}
+
+function onSlotTap(index: number): void {
+    if (selected.value) {
+        // Tapping the slot a chip was picked up from just cancels the pickup.
+        if (selected.value.from === index) {
+            selected.value = null;
+
+            return;
+        }
+
+        assignSlot(selected.value.token, index, selected.value.from);
+        selected.value = null;
+
+        return;
+    }
+
+    const token = slots.value[index];
+
+    if (token !== null) {
+        selected.value = { token, from: index };
+    }
+}
+
+// Tap a matchup's handle to pick it up, then another to drop it there.
+const selectedMatch = ref<number | null>(null);
+
+function onMatchHandleTap(index: number): void {
+    if (selectedMatch.value === null || selectedMatch.value === index) {
+        selectedMatch.value = selectedMatch.value === index ? null : index;
+
+        return;
+    }
+
+    const to = selectedMatch.value < index ? index - 1 : index;
+    moveMatch(selectedMatch.value, to);
+    selectedMatch.value = null;
 }
 
+function roundLabelFor(gameCount: number): string {
+    const labels: Record<number, string> = { 1: 'Final', 2: 'Semifinals', 4: 'Quarterfinals', 8: 'Round of 16', 16: 'Round of 32' };
+
+    return labels[gameCount] ?? `Round of ${gameCount * 2}`;
+}
+
+function roundTag(gameCount: number, index: number): string {
+    const prefixes: Record<number, string> = { 1: 'F', 2: 'SF', 4: 'QF', 8: 'R16', 16: 'M' };
+    const prefix = prefixes[gameCount] ?? `R${gameCount * 2}`;
+
+    return gameCount === 1 ? prefix : `${prefix}${index + 1}`;
+}
+
+/**
+ * The bracket columns after round 1: each later round's games and which
+ * earlier games feed them (by tag — M1, QF1 …). Independent of who's placed,
+ * so the tree is visible while the admin is still filling slots.
+ */
+const derivedRounds = computed<{ label: string; games: { tag: string; feedA: string; feedB: string }[] }[]>(() => {
+    if (matchCount.value < 2 || (matchCount.value & (matchCount.value - 1)) !== 0) {
+        return [];
+    }
+
+    let previousTags = Array.from({ length: matchCount.value }, (_, index) => `M${index + 1}`);
+    const rounds: { label: string; games: { tag: string; feedA: string; feedB: string }[] }[] = [];
+
+    while (previousTags.length > 1) {
+        const gameCount = previousTags.length / 2;
+        const games = [];
+
+        for (let j = 0; j < gameCount; j++) {
+            games.push({ tag: roundTag(gameCount, j), feedA: previousTags[2 * j], feedB: previousTags[2 * j + 1] });
+        }
+
+        rounds.push({ label: roundLabelFor(gameCount), games });
+        previousTags = games.map((game) => game.tag);
+    }
+
+    return rounds;
+});
+
 const formatLabel = props.formats.find((f) => f.value === props.stage.format)?.label ?? props.stage.format;
 
 const pageBreadcrumbs = computed<BreadcrumbItem[]>(() => [
@@ -229,7 +537,7 @@ function submit() {
 <template>
     <Head :title="`Edit ${stage.name}`" />
 
-    <div class="mx-auto flex w-full max-w-2xl flex-col gap-6 p-4 sm:p-6">
+    <div class="mx-auto flex w-full flex-col gap-6 p-4 sm:p-6" :class="isBracketFormat ? 'max-w-6xl' : 'max-w-2xl'">
         <Breadcrumbs :breadcrumbs="pageBreadcrumbs" />
 
         <header>
@@ -240,13 +548,13 @@ function submit() {
         </header>
 
         <form class="flex flex-col gap-5" @submit.prevent="submit">
-            <div class="grid gap-2">
+            <div class="grid max-w-2xl gap-2">
                 <Label for="name">Name</Label>
                 <Input id="name" v-model="form.name" required autofocus />
                 <InputError :message="form.errors.name" />
             </div>
 
-            <div class="grid grid-cols-1 gap-5 sm:grid-cols-2">
+            <div class="grid max-w-2xl grid-cols-1 gap-5 sm:grid-cols-2">
                 <div class="grid gap-2">
                     <Label for="starts_on">Starts on (optional)</Label>
                     <Input id="starts_on" type="date" v-model="form.starts_on" />
@@ -260,7 +568,7 @@ function submit() {
                 </div>
             </div>
 
-            <div class="grid gap-2">
+            <div class="grid max-w-2xl gap-2">
                 <Label for="order">Order</Label>
                 <Input id="order" type="number" min="0" max="65535" v-model="form.order" />
                 <InputError :message="form.errors.order" />
@@ -304,41 +612,129 @@ function submit() {
                         Adjust "Advance per group" or "Best-placed qualifiers" on the group stage.
                     </div>
 
-                    <div class="flex flex-wrap gap-2">
+                    <div class="flex flex-wrap items-center gap-2">
                         <Button v-if="classicTemplateAvailable" type="button" size="sm" variant="outline" @click="applyClassicTemplate">
-                            Classic template (1A v 2B …)
+                            Classic template
                         </Button>
                         <Button type="button" size="sm" variant="outline" :disabled="!qualifierTotalIsPowerOfTwo" @click="applySeededTemplate">
                             Seeded template
                         </Button>
-                        <Button v-if="entrantTokens.length > 0" type="button" size="sm" variant="ghost" class="text-destructive" @click="clearEntrants">
+                        <Button v-if="placedCount > 0" type="button" size="sm" variant="ghost" class="text-destructive" @click="clearEntrants">
                             Clear
                         </Button>
+                        <span class="ml-auto text-xs tabular-nums text-muted-foreground">{{ placedCount }} of {{ bracketSize }} placed</span>
                     </div>
 
-                    <div v-if="entrantTokens.length > 0" class="grid gap-2">
-                        <div
-                            v-for="match in entrantTokens.length / 2"
-                            :key="match"
-                            class="flex flex-wrap items-center gap-2 rounded-md border bg-card px-3 py-2"
-                        >
-                            <span class="w-16 shrink-0 font-display text-xs font-semibold uppercase text-muted-foreground">Match {{ match }}</span>
-                            <Select v-model="entrantTokens[2 * (match - 1)]">
-                                <SelectTrigger class="h-8 w-56 text-xs"><SelectValue /></SelectTrigger>
-                                <SelectContent>
-                                    <SelectItem v-for="option in slotOptions" :key="option.value" :value="option.value">{{ option.label }}</SelectItem>
-                                </SelectContent>
-                            </Select>
-                            <span class="text-xs text-muted-foreground">vs</span>
-                            <Select v-model="entrantTokens[2 * (match - 1) + 1]">
-                                <SelectTrigger class="h-8 w-56 text-xs"><SelectValue /></SelectTrigger>
-                                <SelectContent>
-                                    <SelectItem v-for="option in slotOptions" :key="option.value" :value="option.value">{{ option.label }}</SelectItem>
-                                </SelectContent>
-                            </Select>
+                    <p class="text-xs text-muted-foreground">
+                        Tap a qualifier, then a slot to place it — or drag it across. Reorder a matchup with its <span class="font-semibold">⠿</span> handle (drag it, or tap the handle then another). The later rounds show who's set up to meet.
+                    </p>
+
+                    <div class="grid gap-4 lg:grid-cols-[220px_minmax(0,1fr)]">
+                        <!-- Qualifier palette -->
+                        <div class="flex flex-col gap-2.5 self-start rounded-md border bg-muted/40 p-3 lg:sticky lg:top-4">
+                            <div v-for="group in paletteGroups" :key="group.label" class="flex flex-col gap-1.5">
+                                <p class="text-[11px] font-semibold uppercase tracking-wide text-muted-foreground">{{ group.label }}</p>
+                                <div class="flex flex-wrap gap-1.5">
+                                    <button
+                                        v-for="chip in group.chips"
+                                        :key="chip.token"
+                                        type="button"
+                                        :draggable="!chip.placed"
+                                        :disabled="chip.placed"
+                                        class="inline-flex select-none items-center gap-1.5 rounded-full border bg-card px-2.5 py-1 text-xs font-medium disabled:opacity-40"
+                                        :class="[
+                                            chip.placed ? '' : 'cursor-grab',
+                                            isSelected(chip.token, null) ? 'ring-2 ring-volt' : '',
+                                        ]"
+                                        @click="onChipTap(chip.token)"
+                                        @dragstart="onChipDragStart($event, chip.token, null)"
+                                        @dragend="onDragEnd"
+                                    >
+                                        <span class="h-2 w-2 rounded-full" :class="dotClass(chip.kind)" />
+                                        {{ chip.label }}
+                                    </button>
+                                </div>
+                            </div>
+                        </div>
+
+                        <!-- Visual bracket -->
+                        <div class="min-w-0 overflow-x-auto pb-1">
+                            <div class="flex min-w-max items-stretch gap-5">
+                                <div class="flex min-w-[190px] flex-col justify-around gap-2">
+                                    <p class="text-center text-[11px] font-semibold uppercase tracking-wide text-muted-foreground">{{ firstRoundLabel }}</p>
+                                    <div
+                                        v-for="match in matchCount"
+                                        :key="match"
+                                        class="overflow-hidden rounded-lg border bg-card shadow-sm"
+                                        :class="[
+                                            drag?.kind === 'match' && drag.index === match - 1 ? 'opacity-40' : '',
+                                            dropMatch?.index === match - 1 || selectedMatch === match - 1 ? 'ring-2 ring-inset ring-volt' : '',
+                                        ]"
+                                        @dragover="onMatchDragOver($event, match - 1)"
+                                        @dragleave="dropMatch = null"
+                                        @drop="onMatchDrop($event, match - 1)"
+                                    >
+                                        <div class="flex items-center gap-1.5 border-b bg-muted px-2 py-1">
+                                            <button
+                                                type="button"
+                                                draggable="true"
+                                                class="cursor-grab text-sm leading-none text-muted-foreground hover:text-foreground"
+                                                :class="selectedMatch === match - 1 ? 'text-volt' : ''"
+                                                aria-label="Reorder matchup"
+                                                @click="onMatchHandleTap(match - 1)"
+                                                @dragstart="onMatchDragStart($event, match - 1)"
+                                                @dragend="onDragEnd"
+                                            >⠿</button>
+                                            <span class="font-display text-[11px] font-semibold uppercase tracking-wide text-muted-foreground">Match {{ match }}</span>
+                                        </div>
+                                        <div
+                                            v-for="(slotIndex, side) in matchSlots(match)"
+                                            :key="slotIndex"
+                                            class="flex min-h-[40px] cursor-pointer items-center gap-2 px-2.5 py-2 text-sm"
+                                            :class="[
+                                                side === 1 ? 'border-t border-dashed' : '',
+                                                overSlot === slotIndex || selected?.from === slotIndex ? 'bg-volt/15 ring-1 ring-inset ring-volt' : '',
+                                            ]"
+                                            @click="onSlotTap(slotIndex)"
+                                            @dragover="onSlotDragOver($event, slotIndex)"
+                                            @dragleave="overSlot = null"
+                                            @drop="onSlotDrop(slotIndex)"
+                                        >
+                                            <template v-if="slots[slotIndex]">
+                                                <span class="h-2 w-2 shrink-0 rounded-full" :class="dotClass(kindForToken(slots[slotIndex]!))" />
+                                                <span
+                                                    draggable="true"
+                                                    class="flex-1 cursor-grab truncate font-medium"
+                                                    @dragstart="onChipDragStart($event, slots[slotIndex]!, slotIndex)"
+                                                    @dragend="onDragEnd"
+                                                >{{ slotLabel(slots[slotIndex]!) }}</span>
+                                                <button
+                                                    type="button"
+                                                    class="shrink-0 rounded px-1 text-muted-foreground hover:bg-muted hover:text-foreground"
+                                                    aria-label="Remove qualifier"
+                                                    @click.stop="unassignSlot(slotIndex)"
+                                                >×</button>
+                                            </template>
+                                            <span v-else class="italic text-muted-foreground">{{ selected ? 'Tap to place' : 'Drop a qualifier' }}</span>
+                                        </div>
+                                    </div>
+                                </div>
+
+                                <div v-for="round in derivedRounds" :key="round.label" class="flex min-w-[170px] flex-col justify-around gap-2">
+                                    <p class="text-center text-[11px] font-semibold uppercase tracking-wide text-muted-foreground">{{ round.label }}</p>
+                                    <div v-for="game in round.games" :key="game.tag" class="rounded-lg border border-dashed bg-card/60 px-3 py-2 text-center">
+                                        <p class="font-display text-[11px] font-semibold text-muted-foreground">{{ game.tag }}</p>
+                                        <p class="mt-0.5 text-xs text-muted-foreground">winner {{ game.feedA }} vs winner {{ game.feedB }}</p>
+                                    </div>
+                                </div>
+                            </div>
                         </div>
                     </div>
 
+                    <p v-if="placedCount < bracketSize" class="text-xs text-muted-foreground">
+                        {{ bracketSize - placedCount }} slot{{ bracketSize - placedCount === 1 ? '' : 's' }} still empty — fill every slot to save the bracket.
+                    </p>
+
                     <InputError :message="form.errors['config.entrants']" />
                 </template>
             </div>
@@ -363,7 +759,7 @@ function submit() {
                 </div>
             </div>
 
-            <div class="flex items-center gap-3">
+            <div class="flex max-w-2xl items-center gap-3">
                 <Button type="submit" :disabled="form.processing">Save changes</Button>
                 <Button type="button" variant="ghost" as-child>
                     <Link :href="stageShow([league.slug, season.id, stage.id]).url">Cancel</Link>
diff --git a/tests/Feature/Stages/BracketAdjacencyTest.php b/tests/Feature/Stages/BracketAdjacencyTest.php
new file mode 100644
index 0000000..590ee60
--- /dev/null
+++ b/tests/Feature/Stages/BracketAdjacencyTest.php
@@ -0,0 +1,120 @@
+<?php
+
+use App\Actions\GenerateFixtures;
+use App\Actions\SeedStageFromGroups;
+use App\Enums\GameStatus;
+use App\Models\Game;
+use App\Models\Group;
+use App\Models\League;
+use App\Models\Result;
+use App\Models\Season;
+use App\Models\Stage;
+use App\Models\Team;
+
+/**
+ * Build 8 single-game groups (A–H) whose home side wins, plus a knockout
+ * stage whose entrants are the eight group winners in A…H order. This is
+ * the contract the entrant builder's projected-bracket view mirrors: the
+ * entrant order is the bracket tree, so consecutive round-1 matches feed
+ * each next-round game.
+ *
+ * @return array{0: Stage, 1: array<string, Team>}
+ */
+function bracketAdjacencyScaffold(): array
+{
+    $league = League::factory()->create();
+    $season = Season::factory()->create(['league_id' => $league->id]);
+
+    $groupStage = Stage::factory()->groupStage()->create([
+        'season_id' => $season->id,
+        'name' => 'Groups',
+        'order' => 10,
+        'advances_count' => 1,
+    ]);
+
+    $winners = [];
+    $entrants = [];
+
+    foreach (range('A', 'H') as $letter) {
+        $group = Group::factory()->create(['stage_id' => $groupStage->id, 'name' => "Group {$letter}"]);
+        $winner = Team::factory()->create(['name' => "Winner {$letter}"]);
+        $loser = Team::factory()->create(['name' => "Loser {$letter}"]);
+
+        $season->teams()->attach([$winner->id, $loser->id]);
+        $group->teams()->attach([$winner->id, $loser->id]);
+
+        $game = Game::factory()->create([
+            'stage_id' => $groupStage->id,
+            'season_id' => $season->id,
+            'group_id' => $group->id,
+            'home_team_id' => $winner->id,
+            'away_team_id' => $loser->id,
+            'status' => GameStatus::FullTime,
+            'match_date' => now()->subDay(),
+        ]);
+        Result::factory()->create(['game_id' => $game->id, 'home_team_score' => 2, 'away_team_score' => 0]);
+
+        $winners[$letter] = $winner;
+        $entrants[] = ['type' => 'group', 'group' => "Group {$letter}", 'position' => 1];
+    }
+
+    $knockout = Stage::factory()->singleElimination()->create([
+        'season_id' => $season->id,
+        'name' => 'Knockout',
+        'order' => 20,
+        'config' => ['entrants' => $entrants],
+    ]);
+
+    app(GenerateFixtures::class)->execute($knockout->fresh('season.teams'));
+
+    return [$knockout, $winners];
+}
+
+it('routes adjacent round-1 match winners into the same next-round game', function () {
+    [$knockout, $w] = bracketAdjacencyScaffold();
+
+    app(SeedStageFromGroups::class)->execute($knockout);
+
+    // Decide every round-1 game for the home side — the earlier entrant slot,
+    // i.e. the A/C/E/G group winners — and let advancement promote them.
+    $knockout->games()->where('round', 1)->orderBy('bracket_position')->get()
+        ->each(function (Game $game): void {
+            Result::factory()->create(['game_id' => $game->id, 'home_team_score' => 1, 'away_team_score' => 0]);
+            $game->update(['status' => GameStatus::FullTime]);
+        });
+
+    $round2 = $knockout->games()->where('round', 2)->orderBy('bracket_position')->get();
+
+    // Matches 1 & 2 (Winner A v Winner B, Winner C v Winner D) feed the first
+    // next-round game; matches 3 & 4 feed the second. So the winners set up to
+    // meet are decided purely by the order the matches sit in.
+    expect($round2[0]->home_team_id)->toBe($w['A']->id);
+    expect($round2[0]->away_team_id)->toBe($w['C']->id);
+    expect($round2[1]->home_team_id)->toBe($w['E']->id);
+    expect($round2[1]->away_team_id)->toBe($w['G']->id);
+});
+
+it('changes who meets next round when the match order changes', function () {
+    [$knockout, $w] = bracketAdjacencyScaffold();
+
+    // Swap matches 2 and 3 (bracket positions 1 and 2): now Winner C/D share
+    // the first next-round game's far side with Winner E/F instead.
+    $entrants = $knockout->config['entrants'];
+    [$entrants[2], $entrants[3], $entrants[4], $entrants[5]] = [$entrants[4], $entrants[5], $entrants[2], $entrants[3]];
+    $knockout->update(['config' => ['entrants' => $entrants]]);
+
+    app(SeedStageFromGroups::class)->execute($knockout->fresh());
+
+    $knockout->games()->where('round', 1)->orderBy('bracket_position')->get()
+        ->each(function (Game $game): void {
+            Result::factory()->create(['game_id' => $game->id, 'home_team_score' => 1, 'away_team_score' => 0]);
+            $game->update(['status' => GameStatus::FullTime]);
+        });
+
+    $round2 = $knockout->games()->where('round', 2)->orderBy('bracket_position')->get();
+
+    // Winner A now meets Winner E (match 2 became E v F), confirming the order
+    // drives the pairing.
+    expect($round2[0]->home_team_id)->toBe($w['A']->id);
+    expect($round2[0]->away_team_id)->toBe($w['E']->id);
+});